@angular/core 17.0.0-next.0 → 17.0.0-next.2

package/esm2022/src/render3/instructions/defer.mjs

@@ -5,40 +5,137 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import { InjectionToken } from '../../di';
+import { assertDefined, assertEqual, throwError } from '../../util/assert';
+import { assertIndexInDeclRange, assertLContainer, assertTNodeForLView } from '../assert';
+import { bindingUpdated } from '../bindings';
+import { getComponentDef, getDirectiveDef, getPipeDef } from '../definition';
+import { DEFER_BLOCK_STATE } from '../interfaces/defer';
+import { isDestroyed } from '../interfaces/type_checks';
+import { HEADER_OFFSET, INJECTOR, PARENT, TVIEW } from '../interfaces/view';
+import { getCurrentTNode, getLView, getSelectedTNode, getTView, nextBindingIndex } from '../state';
+import { getConstant, getTNode, removeLViewOnDestroy, storeLViewOnDestroy } from '../util/view_utils';
+import { addLViewToLContainer, createAndRenderEmbeddedLView, removeLViewFromLContainer } from '../view_manipulation';
+import { ɵɵtemplate } from './template';
+/**
+ * Shims for the `requestIdleCallback` and `cancelIdleCallback` functions for environments
+ * where those functions are not available (e.g. Node.js).
+ */
+const _requestIdleCallback = typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;
+const _cancelIdleCallback = typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;
 /**
  * Creates runtime data structures for `{#defer}` blocks.
  *
- * @param deferIndex Index of the underlying deferred block data structure.
- * @param primaryTemplateIndex Index of the template function with the block's content.
- * @param deferredDepsFn Function that contains dependencies for this defer block
- * @param loadingIndex Index of the template with the `{:loading}` block content.
- * @param placeholderIndex Index of the template with the `{:placeholder}` block content.
- * @param error Index of the template with the `{:error}` block content.
- * @param loadingConfigIndex Index in the constants array of the configuration of the `{:loading}`
+ * @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 placeholderConfigIndexIndex in the constants array of the configuration of the
  *     `{:placeholder}` block.
  *
  * @codeGenApi
  */
-export function ɵɵdefer(deferIndex, primaryTemplateIndex, deferredDepsFn, loadingIndex, placeholderIndex, errorIndex, loadingConfigIndex, placeholderConfigIndex) { } // TODO: implement runtime logic.
+export function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplIndex, placeholderTmplIndex, errorTmplIndex, loadingConfigIndex, placeholderConfigIndex) {
+    const lView = getLView();
+    const tView = getTView();
+    const tViewConsts = tView.consts;
+    const adjustedIndex = index + HEADER_OFFSET;
+    ɵɵtemplate(index, null, 0, 0);
+    if (tView.firstCreatePass) {
+        const deferBlockConfig = {
+            primaryTmplIndex,
+            loadingTmplIndex: loadingTmplIndex ?? null,
+            placeholderTmplIndex: placeholderTmplIndex ?? null,
+            errorTmplIndex: errorTmplIndex ?? null,
+            placeholderBlockConfig: placeholderConfigIndex != null ?
+                getConstant(tViewConsts, placeholderConfigIndex) :
+                null,
+            loadingBlockConfig: loadingConfigIndex != null ?
+                getConstant(tViewConsts, loadingConfigIndex) :
+                null,
+            dependencyResolverFn: dependencyResolverFn ?? null,
+            loadingState: 0 /* DeferDependenciesLoadingState.NOT_STARTED */,
+            loadingPromise: null,
+        };
+        setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);
+    }
+    // Init instance-specific defer details and store it.
+    const lDetails = [];
+    lDetails[DEFER_BLOCK_STATE] = 0 /* DeferBlockInstanceState.INITIAL */;
+    setLDeferBlockDetails(lView, adjustedIndex, lDetails);
+}
 /**
- * Loads the deferred content when a value becomes truthy.
+ * Loads defer block dependencies when a trigger value becomes truthy.
  * @codeGenApi
  */
-export function ɵɵdeferWhen(value) { } // TODO: implement runtime logic.
+export function ɵɵdeferWhen(rawValue) {
+    const lView = getLView();
+    const bindingIndex = nextBindingIndex();
+    if (bindingUpdated(lView, bindingIndex, rawValue)) {
+        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 === 0 /* DeferBlockInstanceState.INITIAL */) {
+            // If nothing is rendered yet, render a placeholder (if defined).
+            renderPlaceholder(lView, tNode);
+        }
+        else if (value === true &&
+            (renderedState === 0 /* DeferBlockInstanceState.INITIAL */ ||
+                renderedState === 1 /* DeferBlockInstanceState.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);
+        }
+    }
+}
 /**
  * Prefetches the deferred content when a value becomes truthy.
  * @codeGenApi
  */
-export function ɵɵdeferPrefetchWhen(value) { } // TODO: implement runtime logic.
+export function ɵɵdeferPrefetchWhen(rawValue) {
+    const lView = getLView();
+    const bindingIndex = nextBindingIndex();
+    if (bindingUpdated(lView, bindingIndex, rawValue)) {
+        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 === 0 /* DeferDependenciesLoadingState.NOT_STARTED */) {
+            // If loading has not been started yet, trigger it now.
+            triggerResourceLoading(tDetails, getPrimaryBlockTNode(tView, tDetails), lView[INJECTOR]);
+        }
+    }
+}
 /**
- * Creates runtime data structures for the `on idle` deferred trigger.
+ * Sets up handlers that represent `on idle` deferred trigger.
  * @codeGenApi
  */
-export function ɵɵdeferOnIdle() { } // TODO: implement runtime logic.
+export function ɵɵdeferOnIdle() {
+    const lView = getLView();
+    const tNode = getCurrentTNode();
+    renderPlaceholder(lView, tNode);
+    let id;
+    const removeIdleCallback = () => _cancelIdleCallback(id);
+    id = _requestIdleCallback(() => {
+        removeIdleCallback();
+        // The idle callback is invoked, we no longer need
+        // to retain a cleanup callback in an LView.
+        removeLViewOnDestroy(lView, removeIdleCallback);
+        triggerDeferBlock(lView, tNode);
+    });
+    // Store a cleanup function on LView, so that we cancel idle
+    // callback in case this LView was destroyed before a callback
+    // was invoked.
+    storeLViewOnDestroy(lView, removeIdleCallback);
+}
 /**
- * Creates runtime data structures for the `prefetech on idle` deferred trigger.
+ * Creates runtime data structures for the `prefetch on idle` deferred trigger.
  * @codeGenApi
  */
 export function ɵɵdeferPrefetchOnIdle() { } // TODO: implement runtime logic.
@@ -48,7 +145,7 @@ export function ɵɵdeferPrefetchOnIdle() { } // TODO: implement runtime logic.
  */
 export function ɵɵdeferOnImmediate() { } // TODO: implement runtime logic.
 /**
- * Creates runtime data structures for the `prefetech on immediate` deferred trigger.
+ * Creates runtime data structures for the `prefetch on immediate` deferred trigger.
  * @codeGenApi
  */
 export function ɵɵdeferPrefetchOnImmediate() { } // TODO: implement runtime logic.
@@ -70,7 +167,7 @@ export function ɵɵdeferPrefetchOnTimer(delay) { } // TODO: implement runtime l
  */
 export function ɵɵdeferOnHover() { } // TODO: implement runtime logic.
 /**
- * Creates runtime data structures for the `prefetech on hover` deferred trigger.
+ * Creates runtime data structures for the `prefetch on hover` deferred trigger.
  * @codeGenApi
  */
 export function ɵɵdeferPrefetchOnHover() { } // TODO: implement runtime logic.
@@ -98,4 +195,237 @@ export function ɵɵdeferOnViewport(target) { } // TODO: implement runtime logic
  * @codeGenApi
  */
 export function ɵɵdeferPrefetchOnViewport(target) { } // TODO: implement runtime logic.
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,OAAO,CACnB,UAAkB,EAClB,oBAA4B,EAC5B,cAAoC,EACpC,YAA0B,EAC1B,gBAA8B,EAC9B,UAAwB,EACxB,kBAAgC,EAChC,sBAAoC,IACrC,CAAC,CAAE,iCAAiC;AAEvC;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc,IAAG,CAAC,CAAE,iCAAiC;AAEjF;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAc,IAAG,CAAC,CAAE,iCAAiC;AAEzF;;;GAGG;AACH,MAAM,UAAU,aAAa,KAAI,CAAC,CAAE,iCAAiC;AAErE;;;GAGG;AACH,MAAM,UAAU,qBAAqB,KAAI,CAAC,CAAE,iCAAiC;AAE7E;;;GAGG;AACH,MAAM,UAAU,kBAAkB,KAAI,CAAC,CAAE,iCAAiC;AAG1E;;;GAGG;AACH,MAAM,UAAU,0BAA0B,KAAI,CAAC,CAAE,iCAAiC;AAElF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,IAAG,CAAC,CAAE,iCAAiC;AAEnF;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa,IAAG,CAAC,CAAE,iCAAiC;AAE3F;;;GAGG;AACH,MAAM,UAAU,cAAc,KAAI,CAAC,CAAE,iCAAiC;AAEtE;;;GAGG;AACH,MAAM,UAAU,sBAAsB,KAAI,CAAC,CAAE,iCAAiC;AAE9E;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAE5F;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEpG;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEzF;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC","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.io/license\n */\n\nimport {Type} from '../../interface/type';\n\nexport type DeferredDepsFn = () => Array<Promise<Type<unknown>>|Type<unknown>>;\n\n/** Configuration object for a `{:loading}` block as it is stored in the component constants. */\ntype DeferredLoadingConfig = [minimumTime: number|null, afterTime: number|null];\n\n/** Configuration object for a `{:placeholder}` block as it is stored in the component constants. */\ntype DeferredPlaceholderConfig = [afterTime: number|null];\n\n/**\n * Creates runtime data structures for `{#defer}` blocks.\n *\n * @param deferIndex Index of the underlying deferred block data structure.\n * @param primaryTemplateIndex Index of the template function with the block's content.\n * @param deferredDepsFn Function that contains dependencies for this defer block\n * @param loadingIndex Index of the template with the `{:loading}` block content.\n * @param placeholderIndex Index of the template with the `{:placeholder}` block content.\n * @param error 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 placeholderConfigIndexIndex in the constants array of the configuration of the\n *     `{:placeholder}` block.\n *\n * @codeGenApi\n */\nexport function ɵɵdefer(\n    deferIndex: number,\n    primaryTemplateIndex: number,\n    deferredDepsFn?: DeferredDepsFn|null,\n    loadingIndex?: number|null,\n    placeholderIndex?: number|null,\n    errorIndex?: number|null,\n    loadingConfigIndex?: number|null,\n    placeholderConfigIndex?: number|null,\n) {}  // TODO: implement runtime logic.\n\n/**\n * Loads the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferWhen(value: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Prefetches the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchWhen(value: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnIdle() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetech on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnIdle() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnImmediate() {}  // TODO: implement runtime logic.\n\n\n/**\n * Creates runtime data structures for the `prefetech on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnImmediate() {}  // TODO: implement runtime logic.\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) {}  // TODO: implement runtime logic.\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) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetech on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n"]}
+/********** Helper functions **********/
+/**
+ * Calculates a data slot index for defer block info (either static or
+ * instance-specific), given an index of a defer instruction.
+ */
+function getDeferBlockDataIndex(deferBlockIndex) {
+    // Instance state is located at the *next* position
+    // after the defer block slot in an LView or TView.data.
+    return deferBlockIndex + 1;
+}
+/** Retrieves a defer block state from an LView, given a TNode that represents a block. */
+function getLDeferBlockDetails(lView, tNode) {
+    const tView = lView[TVIEW];
+    const slotIndex = getDeferBlockDataIndex(tNode.index);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    return lView[slotIndex];
+}
+/** Stores a defer block instance state in LView. */
+function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
+    const tView = lView[TVIEW];
+    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    lView[slotIndex] = lDetails;
+}
+/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */
+function getTDeferBlockDetails(tView, tNode) {
+    const slotIndex = getDeferBlockDataIndex(tNode.index);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    return tView.data[slotIndex];
+}
+/** Stores a defer block static info in `TView.data`. */
+function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
+    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    tView.data[slotIndex] = deferBlockConfig;
+}
+/**
+ * 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 stateTmplIndex Index of a template that should be rendered.
+ */
+function renderDeferBlockState(newState, tNode, lContainer, stateTmplIndex) {
+    const hostLView = lContainer[PARENT];
+    // 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');
+    // Note: 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 `2`), we should not show a placeholder
+    // (represented as `1`).
+    if (lDetails[DEFER_BLOCK_STATE] < newState && stateTmplIndex !== null) {
+        lDetails[DEFER_BLOCK_STATE] = newState;
+        const hostTView = hostLView[TVIEW];
+        const adjustedIndex = stateTmplIndex + HEADER_OFFSET;
+        const tNode = 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);
+        const embeddedLView = createAndRenderEmbeddedLView(hostLView, tNode, null);
+        addLViewToLContainer(lContainer, embeddedLView, viewIndex);
+    }
+}
+/**
+ * Trigger loading of defer block dependencies if the process hasn't started yet.
+ *
+ * @param tDetails Static information about this defer block.
+ * @param primaryBlockTNode TNode of a primary block template.
+ * @param injector Environment injector of the application.
+ */
+function triggerResourceLoading(tDetails, primaryBlockTNode, injector) {
+    const tView = primaryBlockTNode.tView;
+    if (tDetails.loadingState !== 0 /* 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;
+    }
+    // Switch from NOT_STARTED -> IN_PROGRESS state.
+    tDetails.loadingState = 1 /* DeferDependenciesLoadingState.IN_PROGRESS */;
+    // Check if dependency function interceptor is configured.
+    const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, { optional: true });
+    const dependenciesFn = deferDependencyInterceptor ?
+        deferDependencyInterceptor.intercept(tDetails.dependencyResolverFn) :
+        tDetails.dependencyResolverFn;
+    // The `dependenciesFn` might be `null` when all dependencies within
+    // a given `{#defer}` block were eagerly references elsewhere in a file,
+    // thus no dynamic `import()`s were produced.
+    if (!dependenciesFn) {
+        tDetails.loadingPromise = Promise.resolve().then(() => {
+            tDetails.loadingState = 2 /* DeferDependenciesLoadingState.COMPLETE */;
+        });
+        return;
+    }
+    // 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 this Promise.
+        tDetails.loadingPromise = null;
+        if (failed) {
+            tDetails.loadingState = 3 /* DeferDependenciesLoadingState.FAILED */;
+        }
+        else {
+            tDetails.loadingState = 2 /* DeferDependenciesLoadingState.COMPLETE */;
+            // Update directive and pipe registries to add newly downloaded dependencies.
+            if (directiveDefs.length > 0) {
+                tView.directiveRegistry = tView.directiveRegistry ?
+                    [...tView.directiveRegistry, ...directiveDefs] :
+                    directiveDefs;
+            }
+            if (pipeDefs.length > 0) {
+                tView.pipeRegistry = tView.pipeRegistry ? [...tView.pipeRegistry, ...pipeDefs] : pipeDefs;
+            }
+        }
+    });
+}
+/** Utility function to render `{:placeholder}` content (if present) */
+function renderPlaceholder(lView, tNode) {
+    const tView = lView[TVIEW];
+    const lContainer = lView[tNode.index];
+    ngDevMode && assertLContainer(lContainer);
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    renderDeferBlockState(1 /* DeferBlockInstanceState.PLACEHOLDER */, tNode, lContainer, tDetails.placeholderTmplIndex);
+}
+/**
+ * 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 === 2 /* DeferDependenciesLoadingState.COMPLETE */) {
+            ngDevMode && assertDeferredDependenciesLoaded(tDetails);
+            // Everything is loaded, show the primary block content
+            renderDeferBlockState(3 /* DeferBlockInstanceState.COMPLETE */, tNode, lContainer, tDetails.primaryTmplIndex);
+        }
+        else if (tDetails.loadingState === 3 /* DeferDependenciesLoadingState.FAILED */) {
+            renderDeferBlockState(4 /* DeferBlockInstanceState.ERROR */, tNode, lContainer, tDetails.errorTmplIndex);
+        }
+    });
+}
+/** Retrieves a TNode that represents main content of a defer block. */
+function getPrimaryBlockTNode(tView, tDetails) {
+    const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
+    return getTNode(tView, adjustedIndex);
+}
+/**
+ * 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];
+    ngDevMode && assertLContainer(lContainer);
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    // Condition is triggered, try to render loading state and start downloading.
+    // Note: if a block is in a loading, completed or an error state, this call would be a noop.
+    renderDeferBlockState(2 /* DeferBlockInstanceState.LOADING */, tNode, lContainer, tDetails.loadingTmplIndex);
+    switch (tDetails.loadingState) {
+        case 0 /* DeferDependenciesLoadingState.NOT_STARTED */:
+            triggerResourceLoading(tDetails, getPrimaryBlockTNode(lView[TVIEW], tDetails), lView[INJECTOR]);
+            // The `loadingState` might have changed to "loading".
+            if (tDetails.loadingState ===
+                1 /* DeferDependenciesLoadingState.IN_PROGRESS */) {
+                renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
+            }
+            break;
+        case 1 /* DeferDependenciesLoadingState.IN_PROGRESS */:
+            renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
+            break;
+        case 2 /* DeferDependenciesLoadingState.COMPLETE */:
+            ngDevMode && assertDeferredDependenciesLoaded(tDetails);
+            renderDeferBlockState(3 /* DeferBlockInstanceState.COMPLETE */, tNode, lContainer, tDetails.primaryTmplIndex);
+            break;
+        case 3 /* DeferDependenciesLoadingState.FAILED */:
+            renderDeferBlockState(4 /* DeferBlockInstanceState.ERROR */, tNode, lContainer, tDetails.errorTmplIndex);
+            break;
+        default:
+            if (ngDevMode) {
+                throwError('Unknown defer block state');
+            }
+    }
+}
+/**
+ * Asserts whether all dependencies for a defer block are loaded.
+ * Always run this function (in dev mode) before rendering a defer
+ * block in completed state.
+ */
+function assertDeferredDependenciesLoaded(tDetails) {
+    assertEqual(tDetails.loadingState, 2 /* DeferDependenciesLoadingState.COMPLETE */, 'Expecting all deferred dependencies to be loaded.');
+}
+/**
+ * **INTERNAL**, avoid referencing it in application code.
+ *
+ * Injector token that allows to provide `DeferBlockDependencyInterceptor` class
+ * implementation.
+ */
+export const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_DEPENDENCY_INTERCEPTOR' : '');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAW,MAAM,UAAU,CAAC;AAClD,OAAO,EAAC,aAAa,EAAE,WAAW,EAAE,UAAU,EAAC,MAAM,mBAAmB,CAAC;AACzE,OAAO,EAAC,sBAAsB,EAAE,gBAAgB,EAAE,mBAAmB,EAAC,MAAM,WAAW,CAAC;AACxF,OAAO,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAE3E,OAAO,EAAC,iBAAiB,EAAmL,MAAM,qBAAqB,CAAC;AAGxO,OAAO,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAC,aAAa,EAAE,QAAQ,EAAS,MAAM,EAAE,KAAK,EAAQ,MAAM,oBAAoB,CAAC;AACxF,OAAO,EAAC,eAAe,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,EAAC,MAAM,UAAU,CAAC;AACjG,OAAO,EAAC,WAAW,EAAE,QAAQ,EAAE,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AACpG,OAAO,EAAC,oBAAoB,EAAE,4BAA4B,EAAE,yBAAyB,EAAC,MAAM,sBAAsB,CAAC;AAEnH,OAAO,EAAC,UAAU,EAAC,MAAM,YAAY,CAAC;AAEtC;;;GAGG;AACH,MAAM,oBAAoB,GACtB,OAAO,mBAAmB,KAAK,WAAW,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,UAAU,CAAC;AAClF,MAAM,mBAAmB,GACrB,OAAO,mBAAmB,KAAK,WAAW,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,YAAY,CAAC;AAEnF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,OAAO,CACnB,KAAa,EAAE,gBAAwB,EAAE,oBAAgD,EACzF,gBAA8B,EAAE,oBAAkC,EAClE,cAA4B,EAAE,kBAAgC,EAC9D,sBAAoC;IACtC,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC;IACjC,MAAM,aAAa,GAAG,KAAK,GAAG,aAAa,CAAC;IAE5C,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE9B,IAAI,KAAK,CAAC,eAAe,EAAE;QACzB,MAAM,gBAAgB,GAAuB;YAC3C,gBAAgB;YAChB,gBAAgB,EAAE,gBAAgB,IAAI,IAAI;YAC1C,oBAAoB,EAAE,oBAAoB,IAAI,IAAI;YAClD,cAAc,EAAE,cAAc,IAAI,IAAI;YACtC,sBAAsB,EAAE,sBAAsB,IAAI,IAAI,CAAC,CAAC;gBACpD,WAAW,CAAiC,WAAW,EAAE,sBAAsB,CAAC,CAAC,CAAC;gBAClF,IAAI;YACR,kBAAkB,EAAE,kBAAkB,IAAI,IAAI,CAAC,CAAC;gBAC5C,WAAW,CAA6B,WAAW,EAAE,kBAAkB,CAAC,CAAC,CAAC;gBAC1E,IAAI;YACR,oBAAoB,EAAE,oBAAoB,IAAI,IAAI;YAClD,YAAY,mDAA2C;YACvD,cAAc,EAAE,IAAI;SACrB,CAAC;QAEF,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,gBAAgB,CAAC,CAAC;KAC/D;IAED,qDAAqD;IACrD,MAAM,QAAQ,GAAG,EAAE,CAAC;IACpB,QAAQ,CAAC,iBAAiB,CAAC,0CAAkC,CAAC;IAC9D,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,QAA8B,CAAC,CAAC;AAC9E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,QAAiB;IAC3C,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,YAAY,GAAG,gBAAgB,EAAE,CAAC;IAExC,IAAI,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE;QACjD,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAE,gCAAgC;QAClE,MAAM,KAAK,GAAG,gBAAgB,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrD,MAAM,aAAa,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC;QAClD,IAAI,KAAK,KAAK,KAAK,IAAI,aAAa,4CAAoC,EAAE;YACxE,iEAAiE;YACjE,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SACjC;aAAM,IACH,KAAK,KAAK,IAAI;YACd,CAAC,aAAa,4CAAoC;gBACjD,aAAa,gDAAwC,CAAC,EAAE;YAC3D,0EAA0E;YAC1E,2EAA2E;YAC3E,SAAS;YACT,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SACjC;KACF;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAiB;IACnD,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,YAAY,GAAG,gBAAgB,EAAE,CAAC;IAExC,IAAI,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE;QACjD,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAE,gCAAgC;QAClE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,KAAK,GAAG,gBAAgB,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrD,IAAI,KAAK,KAAK,IAAI,IAAI,QAAQ,CAAC,YAAY,sDAA8C,EAAE;YACzF,uDAAuD;YACvD,sBAAsB,CAAC,QAAQ,EAAE,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAE,CAAC,CAAC;SAC3F;KACF;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,eAAe,EAAG,CAAC;IAEjC,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEhC,IAAI,EAAU,CAAC;IACf,MAAM,kBAAkB,GAAG,GAAG,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;IACzD,EAAE,GAAG,oBAAoB,CAAC,GAAG,EAAE;QACxB,kBAAkB,EAAE,CAAC;QACrB,kDAAkD;QAClD,4CAA4C;QAC5C,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;QAChD,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC,CAAW,CAAC;IAElB,4DAA4D;IAC5D,8DAA8D;IAC9D,eAAe;IACf,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,KAAI,CAAC,CAAE,iCAAiC;AAE7E;;;GAGG;AACH,MAAM,UAAU,kBAAkB,KAAI,CAAC,CAAE,iCAAiC;AAG1E;;;GAGG;AACH,MAAM,UAAU,0BAA0B,KAAI,CAAC,CAAE,iCAAiC;AAElF;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,IAAG,CAAC,CAAE,iCAAiC;AAEnF;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa,IAAG,CAAC,CAAE,iCAAiC;AAE3F;;;GAGG;AACH,MAAM,UAAU,cAAc,KAAI,CAAC,CAAE,iCAAiC;AAEtE;;;GAGG;AACH,MAAM,UAAU,sBAAsB,KAAI,CAAC,CAAE,iCAAiC;AAE9E;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAE5F;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEpG;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEzF;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAAgB,IAAG,CAAC,CAAE,iCAAiC;AAEjG,wCAAwC;AAExC;;;GAGG;AACH,SAAS,sBAAsB,CAAC,eAAuB;IACrD,mDAAmD;IACnD,wDAAwD;IACxD,OAAO,eAAe,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED,0FAA0F;AAC1F,SAAS,qBAAqB,CAAC,KAAY,EAAE,KAAY;IACvD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,SAAS,GAAG,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtD,SAAS,IAAI,sBAAsB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IACtD,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC;AAC1B,CAAC;AAED,oDAAoD;AACpD,SAAS,qBAAqB,CAC1B,KAAY,EAAE,eAAuB,EAAE,QAA4B;IACrE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,SAAS,GAAG,sBAAsB,CAAC,eAAe,CAAC,CAAC;IAC1D,SAAS,IAAI,sBAAsB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IACtD,KAAK,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC;AAC9B,CAAC;AAED,oGAAoG;AACpG,SAAS,qBAAqB,CAAC,KAAY,EAAE,KAAY;IACvD,MAAM,SAAS,GAAG,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtD,SAAS,IAAI,sBAAsB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IACtD,OAAO,KAAK,CAAC,IAAI,CAAC,SAAS,CAAuB,CAAC;AACrD,CAAC;AAED,wDAAwD;AACxD,SAAS,qBAAqB,CAC1B,KAAY,EAAE,eAAuB,EAAE,gBAAoC;IAC7E,MAAM,SAAS,GAAG,sBAAsB,CAAC,eAAe,CAAC,CAAC;IAC1D,SAAS,IAAI,sBAAsB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IACtD,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,gBAAgB,CAAC;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,qBAAqB,CAC1B,QAAiC,EAAE,KAAY,EAAE,UAAsB,EACvE,cAA2B;IAC7B,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAErC,4EAA4E;IAC5E,uEAAuE;IACvE,IAAI,WAAW,CAAC,SAAS,CAAC;QAAE,OAAO;IAEnC,oEAAoE;IACpE,SAAS,IAAI,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAEnD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAEzD,SAAS,IAAI,aAAa,CAAC,QAAQ,EAAE,sCAAsC,CAAC,CAAC;IAE7E,8EAA8E;IAC9E,8EAA8E;IAC9E,4EAA4E;IAC5E,wBAAwB;IACxB,IAAI,QAAQ,CAAC,iBAAiB,CAAC,GAAG,QAAQ,IAAI,cAAc,KAAK,IAAI,EAAE;QACrE,QAAQ,CAAC,iBAAiB,CAAC,GAAG,QAAQ,CAAC;QACvC,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,aAAa,GAAG,cAAc,GAAG,aAAa,CAAC;QACrD,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAmB,CAAC;QAEnE,iEAAiE;QACjE,mEAAmE;QACnE,MAAM,SAAS,GAAG,CAAC,CAAC;QACpB,yBAAyB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACjD,MAAM,aAAa,GAAG,4BAA4B,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAC3E,oBAAoB,CAAC,UAAU,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;KAC5D;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,sBAAsB,CAC3B,QAA4B,EAAE,iBAAwB,EAAE,QAAkB;IAC5E,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAM,CAAC;IAEvC,IAAI,QAAQ,CAAC,YAAY,sDAA8C,EAAE;QACvE,qEAAqE;QACrE,wEAAwE;QACxE,4EAA4E;QAC5E,OAAO;KACR;IAED,gDAAgD;IAChD,QAAQ,CAAC,YAAY,oDAA4C,CAAC;IAElE,0DAA0D;IAC1D,MAAM,0BAA0B,GAC5B,QAAQ,CAAC,GAAG,CAAC,kCAAkC,EAAE,IAAI,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;IAE7E,MAAM,cAAc,GAAG,0BAA0B,CAAC,CAAC;QAC/C,0BAA0B,CAAC,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC,CAAC;QACrE,QAAQ,CAAC,oBAAoB,CAAC;IAElC,oEAAoE;IACpE,wEAAwE;IACxE,6CAA6C;IAC7C,IAAI,CAAC,cAAc,EAAE;QACnB,QAAQ,CAAC,cAAc,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YACpD,QAAQ,CAAC,YAAY,iDAAyC,CAAC;QACjE,CAAC,CAAC,CAAC;QACH,OAAO;KACR;IAED,iDAAiD;IACjD,QAAQ,CAAC,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;QAC5E,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,MAAM,aAAa,GAAqB,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAgB,EAAE,CAAC;QAEjC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;YAC5B,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,EAAE;gBACjC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC;gBAChC,MAAM,YAAY,GAAG,eAAe,CAAC,UAAU,CAAC,IAAI,eAAe,CAAC,UAAU,CAAC,CAAC;gBAChF,IAAI,YAAY,EAAE;oBAChB,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;iBAClC;qBAAM;oBACL,MAAM,OAAO,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;oBACvC,IAAI,OAAO,EAAE;wBACX,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;qBACxB;iBACF;aACF;iBAAM;gBACL,MAAM,GAAG,IAAI,CAAC;gBACd,MAAM;aACP;SACF;QAED,wDAAwD;QACxD,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC;QAE/B,IAAI,MAAM,EAAE;YACV,QAAQ,CAAC,YAAY,+CAAuC,CAAC;SAC9D;aAAM;YACL,QAAQ,CAAC,YAAY,iDAAyC,CAAC;YAE/D,6EAA6E;YAC7E,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC5B,KAAK,CAAC,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAC;oBAC/C,CAAC,GAAG,KAAK,CAAC,iBAAiB,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC;oBAChD,aAAa,CAAC;aACnB;YACD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;gBACvB,KAAK,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,YAAY,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;aAC3F;SACF;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,uEAAuE;AACvE,SAAS,iBAAiB,CAAC,KAAY,EAAE,KAAY;IACnD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtC,SAAS,IAAI,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAE1C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACrD,qBAAqB,8CACoB,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;GAMG;AACH,SAAS,oCAAoC,CACzC,QAA4B,EAAE,KAAY,EAAE,UAAsB;IACpE,SAAS;QACL,aAAa,CACT,QAAQ,CAAC,cAAc,EAAE,uDAAuD,CAAC,CAAC;IAE1F,QAAQ,CAAC,cAAe,CAAC,IAAI,CAAC,GAAG,EAAE;QACjC,IAAI,QAAQ,CAAC,YAAY,mDAA2C,EAAE;YACpE,SAAS,IAAI,gCAAgC,CAAC,QAAQ,CAAC,CAAC;YAExD,uDAAuD;YACvD,qBAAqB,2CACiB,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;SAErF;aAAM,IAAI,QAAQ,CAAC,YAAY,iDAAyC,EAAE;YACzE,qBAAqB,wCACc,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC;SAChF;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,uEAAuE;AACvE,SAAS,oBAAoB,CAAC,KAAY,EAAE,QAA4B;IACtE,MAAM,aAAa,GAAG,QAAQ,CAAC,gBAAgB,GAAG,aAAa,CAAC;IAChE,OAAO,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAmB,CAAC;AAC1D,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,KAAY,EAAE,KAAY;IACnD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtC,SAAS,IAAI,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAE1C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAErD,6EAA6E;IAC7E,4FAA4F;IAC5F,qBAAqB,0CACgB,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAEnF,QAAQ,QAAQ,CAAC,YAAY,EAAE;QAC7B;YACE,sBAAsB,CAClB,QAAQ,EAAE,oBAAoB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAE,CAAC,CAAC;YAE9E,sDAAsD;YACtD,IAAK,QAAQ,CAAC,YAA8C;iEACf,EAAE;gBAC7C,oCAAoC,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;aACnE;YACD,MAAM;QACR;YACE,oCAAoC,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;YAClE,MAAM;QACR;YACE,SAAS,IAAI,gCAAgC,CAAC,QAAQ,CAAC,CAAC;YACxD,qBAAqB,2CACiB,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;YACpF,MAAM;QACR;YACE,qBAAqB,wCACc,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC;YAC/E,MAAM;QACR;YACE,IAAI,SAAS,EAAE;gBACb,UAAU,CAAC,2BAA2B,CAAC,CAAC;aACzC;KACJ;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,gCAAgC,CAAC,QAA4B;IACpE,WAAW,CACP,QAAQ,CAAC,YAAY,kDACrB,mDAAmD,CAAC,CAAC;AAC3D,CAAC;AAsBD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAC3C,IAAI,cAAc,CACd,SAAS,CAAC,CAAC,CAAC,oCAAoC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC","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.io/license\n */\n\nimport {InjectionToken, Injector} from '../../di';\nimport {assertDefined, assertEqual, throwError} from '../../util/assert';\nimport {assertIndexInDeclRange, assertLContainer, assertTNodeForLView} from '../assert';\nimport {bindingUpdated} from '../bindings';\nimport {getComponentDef, getDirectiveDef, getPipeDef} from '../definition';\nimport {LContainer} from '../interfaces/container';\nimport {DEFER_BLOCK_STATE, DeferBlockInstanceState, DeferDependenciesLoadingState, DeferredLoadingBlockConfig, DeferredPlaceholderBlockConfig, DependencyResolverFn, LDeferBlockDetails, TDeferBlockDetails} from '../interfaces/defer';\nimport {DirectiveDefList, PipeDefList} from '../interfaces/definition';\nimport {TContainerNode, TNode} from '../interfaces/node';\nimport {isDestroyed} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, INJECTOR, LView, PARENT, TVIEW, TView} from '../interfaces/view';\nimport {getCurrentTNode, getLView, getSelectedTNode, getTView, nextBindingIndex} from '../state';\nimport {getConstant, getTNode, removeLViewOnDestroy, storeLViewOnDestroy} from '../util/view_utils';\nimport {addLViewToLContainer, createAndRenderEmbeddedLView, removeLViewFromLContainer} from '../view_manipulation';\n\nimport {ɵɵtemplate} from './template';\n\n/**\n * Shims for the `requestIdleCallback` and `cancelIdleCallback` functions for environments\n * where those functions are not available (e.g. Node.js).\n */\nconst _requestIdleCallback =\n    typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;\nconst _cancelIdleCallback =\n    typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;\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 placeholderConfigIndexIndex in the constants array of the configuration of the\n *     `{:placeholder}` block.\n *\n * @codeGenApi\n */\nexport function ɵɵdefer(\n    index: number, primaryTmplIndex: number, dependencyResolverFn?: DependencyResolverFn|null,\n    loadingTmplIndex?: number|null, placeholderTmplIndex?: number|null,\n    errorTmplIndex?: number|null, loadingConfigIndex?: number|null,\n    placeholderConfigIndex?: number|null) {\n  const lView = getLView();\n  const tView = getTView();\n  const tViewConsts = tView.consts;\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  ɵɵtemplate(index, null, 0, 0);\n\n  if (tView.firstCreatePass) {\n    const deferBlockConfig: TDeferBlockDetails = {\n      primaryTmplIndex,\n      loadingTmplIndex: loadingTmplIndex ?? null,\n      placeholderTmplIndex: placeholderTmplIndex ?? null,\n      errorTmplIndex: errorTmplIndex ?? null,\n      placeholderBlockConfig: placeholderConfigIndex != null ?\n          getConstant<DeferredPlaceholderBlockConfig>(tViewConsts, placeholderConfigIndex) :\n          null,\n      loadingBlockConfig: loadingConfigIndex != null ?\n          getConstant<DeferredLoadingBlockConfig>(tViewConsts, loadingConfigIndex) :\n          null,\n      dependencyResolverFn: dependencyResolverFn ?? null,\n      loadingState: DeferDependenciesLoadingState.NOT_STARTED,\n      loadingPromise: null,\n    };\n\n    setTDeferBlockDetails(tView, adjustedIndex, deferBlockConfig);\n  }\n\n  // Init instance-specific defer details and store it.\n  const lDetails = [];\n  lDetails[DEFER_BLOCK_STATE] = DeferBlockInstanceState.INITIAL;\n  setLDeferBlockDetails(lView, adjustedIndex, lDetails as LDeferBlockDetails);\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\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\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 === DeferBlockInstanceState.INITIAL) {\n      // If nothing is rendered yet, render a placeholder (if defined).\n      renderPlaceholder(lView, tNode);\n    } else if (\n        value === true &&\n        (renderedState === DeferBlockInstanceState.INITIAL ||\n         renderedState === DeferBlockInstanceState.PLACEHOLDER)) {\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  }\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 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      triggerResourceLoading(tDetails, getPrimaryBlockTNode(tView, tDetails), lView[INJECTOR]!);\n    }\n  }\n}\n\n/**\n * Sets up handlers that represent `on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnIdle() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n\n  let id: number;\n  const removeIdleCallback = () => _cancelIdleCallback(id);\n  id = _requestIdleCallback(() => {\n         removeIdleCallback();\n         // The idle callback is invoked, we no longer need\n         // to retain a cleanup callback in an LView.\n         removeLViewOnDestroy(lView, removeIdleCallback);\n         triggerDeferBlock(lView, tNode);\n       }) as number;\n\n  // Store a cleanup function on LView, so that we cancel idle\n  // callback in case this LView was destroyed before a callback\n  // was invoked.\n  storeLViewOnDestroy(lView, removeIdleCallback);\n}\n\n/**\n * Creates runtime data structures for the `prefetch on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnIdle() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnImmediate() {}  // TODO: implement runtime logic.\n\n\n/**\n * Creates runtime data structures for the `prefetch on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnImmediate() {}  // TODO: implement runtime logic.\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) {}  // TODO: implement runtime logic.\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) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on hover` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnHover() {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on interaction` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnInteraction(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n\n/**\n * Creates runtime data structures for the `prefetch on viewport` deferred trigger.\n * @param target Optional element on which to listen for hover events.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnViewport(target?: unknown) {}  // TODO: implement runtime logic.\n\n/********** Helper functions **********/\n\n/**\n * Calculates a data slot index for defer block info (either static or\n * instance-specific), given an index of a defer instruction.\n */\nfunction getDeferBlockDataIndex(deferBlockIndex: number) {\n  // Instance state is located at the *next* position\n  // after the defer block slot in an LView or TView.data.\n  return deferBlockIndex + 1;\n}\n\n/** Retrieves a defer block state from an LView, given a TNode that represents a block. */\nfunction getLDeferBlockDetails(lView: LView, tNode: TNode): LDeferBlockDetails {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return lView[slotIndex];\n}\n\n/** Stores a defer block instance state in LView. */\nfunction setLDeferBlockDetails(\n    lView: LView, deferBlockIndex: number, lDetails: LDeferBlockDetails) {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  lView[slotIndex] = lDetails;\n}\n\n/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */\nfunction getTDeferBlockDetails(tView: TView, tNode: TNode): TDeferBlockDetails {\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return tView.data[slotIndex] as TDeferBlockDetails;\n}\n\n/** Stores a defer block static info in `TView.data`. */\nfunction setTDeferBlockDetails(\n    tView: TView, deferBlockIndex: number, deferBlockConfig: TDeferBlockDetails) {\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  tView.data[slotIndex] = deferBlockConfig;\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 stateTmplIndex Index of a template that should be rendered.\n */\nfunction renderDeferBlockState(\n    newState: DeferBlockInstanceState, tNode: TNode, lContainer: LContainer,\n    stateTmplIndex: number|null): void {\n  const hostLView = lContainer[PARENT];\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  // Note: 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 `2`), we should not show a placeholder\n  // (represented as `1`).\n  if (lDetails[DEFER_BLOCK_STATE] < newState && stateTmplIndex !== null) {\n    lDetails[DEFER_BLOCK_STATE] = newState;\n    const hostTView = hostLView[TVIEW];\n    const adjustedIndex = stateTmplIndex + HEADER_OFFSET;\n    const tNode = 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    removeLViewFromLContainer(lContainer, viewIndex);\n    const embeddedLView = createAndRenderEmbeddedLView(hostLView, tNode, null);\n    addLViewToLContainer(lContainer, embeddedLView, viewIndex);\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 primaryBlockTNode TNode of a primary block template.\n * @param injector Environment injector of the application.\n */\nfunction triggerResourceLoading(\n    tDetails: TDeferBlockDetails, primaryBlockTNode: TNode, injector: Injector) {\n  const tView = primaryBlockTNode.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;\n  }\n\n  // Switch from NOT_STARTED -> IN_PROGRESS state.\n  tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;\n\n  // Check if dependency function interceptor is configured.\n  const deferDependencyInterceptor =\n      injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, {optional: true});\n\n  const dependenciesFn = deferDependencyInterceptor ?\n      deferDependencyInterceptor.intercept(tDetails.dependencyResolverFn) :\n      tDetails.dependencyResolverFn;\n\n  // The `dependenciesFn` might be `null` when all dependencies within\n  // a given `{#defer}` block were eagerly references elsewhere in a file,\n  // thus no dynamic `import()`s were produced.\n  if (!dependenciesFn) {\n    tDetails.loadingPromise = Promise.resolve().then(() => {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n    });\n    return;\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 this Promise.\n    tDetails.loadingPromise = null;\n\n    if (failed) {\n      tDetails.loadingState = DeferDependenciesLoadingState.FAILED;\n    } else {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n\n      // Update directive and pipe registries to add newly downloaded dependencies.\n      if (directiveDefs.length > 0) {\n        tView.directiveRegistry = tView.directiveRegistry ?\n            [...tView.directiveRegistry, ...directiveDefs] :\n            directiveDefs;\n      }\n      if (pipeDefs.length > 0) {\n        tView.pipeRegistry = tView.pipeRegistry ? [...tView.pipeRegistry, ...pipeDefs] : pipeDefs;\n      }\n    }\n  });\n}\n\n/** Utility function to render `{:placeholder}` content (if present) */\nfunction renderPlaceholder(lView: LView, tNode: TNode) {\n  const tView = lView[TVIEW];\n  const lContainer = lView[tNode.index];\n  ngDevMode && assertLContainer(lContainer);\n\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n  renderDeferBlockState(\n      DeferBlockInstanceState.PLACEHOLDER, tNode, lContainer, tDetails.placeholderTmplIndex);\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, tNode: TNode, lContainer: LContainer) {\n  ngDevMode &&\n      assertDefined(\n          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(\n          DeferBlockInstanceState.COMPLETE, tNode, lContainer, tDetails.primaryTmplIndex);\n\n    } else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {\n      renderDeferBlockState(\n          DeferBlockInstanceState.ERROR, tNode, lContainer, tDetails.errorTmplIndex);\n    }\n  });\n}\n\n/** Retrieves a TNode that represents main content of a defer block. */\nfunction getPrimaryBlockTNode(tView: TView, tDetails: TDeferBlockDetails): TContainerNode {\n  const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;\n  return getTNode(tView, adjustedIndex) as TContainerNode;\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  ngDevMode && assertLContainer(lContainer);\n\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  // Condition is triggered, try to render loading state and start downloading.\n  // Note: if a block is in a loading, completed or an error state, this call would be a noop.\n  renderDeferBlockState(\n      DeferBlockInstanceState.LOADING, tNode, lContainer, tDetails.loadingTmplIndex);\n\n  switch (tDetails.loadingState) {\n    case DeferDependenciesLoadingState.NOT_STARTED:\n      triggerResourceLoading(\n          tDetails, getPrimaryBlockTNode(lView[TVIEW], tDetails), lView[INJECTOR]!);\n\n      // The `loadingState` might have changed to \"loading\".\n      if ((tDetails.loadingState as DeferDependenciesLoadingState) ===\n          DeferDependenciesLoadingState.IN_PROGRESS) {\n        renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      }\n      break;\n    case DeferDependenciesLoadingState.IN_PROGRESS:\n      renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.COMPLETE:\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n      renderDeferBlockState(\n          DeferBlockInstanceState.COMPLETE, tNode, lContainer, tDetails.primaryTmplIndex);\n      break;\n    case DeferDependenciesLoadingState.FAILED:\n      renderDeferBlockState(\n          DeferBlockInstanceState.ERROR, tNode, lContainer, tDetails.errorTmplIndex);\n      break;\n    default:\n      if (ngDevMode) {\n        throwError('Unknown defer block state');\n      }\n  }\n}\n\n/**\n * Asserts whether all dependencies for a defer block are loaded.\n * Always run this function (in dev mode) before rendering a defer\n * block in completed state.\n */\nfunction assertDeferredDependenciesLoaded(tDetails: TDeferBlockDetails) {\n  assertEqual(\n      tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE,\n      'Expecting all deferred dependencies to be loaded.');\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Describes a helper class that allows to intercept a call to retrieve current\n * dependency loading function and replace it with a different implementation.\n * This interceptor class is needed to allow testing blocks in different states\n * by simulating loading response.\n */\nexport interface DeferBlockDependencyInterceptor {\n  /**\n   * Invoked for each defer block when dependency loading function is accessed.\n   */\n  intercept(dependencyFn: DependencyResolverFn|null): DependencyResolverFn|null;\n\n  /**\n   * Allows to configure an interceptor function.\n   */\n  setInterceptor(interceptorFn: (current: DependencyResolverFn) => DependencyResolverFn): void;\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Injector token that allows to provide `DeferBlockDependencyInterceptor` class\n * implementation.\n */\nexport const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR =\n    new InjectionToken<DeferBlockDependencyInterceptor>(\n        ngDevMode ? 'DEFER_BLOCK_DEPENDENCY_INTERCEPTOR' : '');\n"]}

package/esm2022/src/render3/instructions/template.mjs

@@ -72,6 +72,7 @@ export function ɵɵtemplate(index, templateFn, decls, vars, tagName, attrsIndex
     if (localRefsIndex != null) {
         saveResolvedLocalsInData(lView, tNode, localRefExtractor);
     }
+    return ɵɵtemplate;
 }
 let _locateOrCreateContainerAnchor = createContainerAnchorImpl;
 /**
@@ -127,4 +128,4 @@ function locateOrCreateContainerAnchorImpl(tView, lView, tNode, index) {
 export function enableLocateOrCreateContainerAnchorImpl() {
     _locateOrCreateContainerAnchor = locateOrCreateContainerAnchorImpl;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/template.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.io/license\n */\nimport {validateMatchingNode, validateNodeExists} from '../../hydration/error_handling';\nimport {TEMPLATES} from '../../hydration/interfaces';\nimport {locateNextRNode, siblingAfter} from '../../hydration/node_lookup_utils';\nimport {calcSerializedContainerSize, isDisconnectedNode, markRNodeAsClaimedByHydration, setSegmentHead} from '../../hydration/utils';\nimport {assertEqual} from '../../util/assert';\nimport {assertFirstCreatePass} from '../assert';\nimport {attachPatchData} from '../context_discovery';\nimport {registerPostOrderHooks} from '../hooks';\nimport {ComponentTemplate} from '../interfaces/definition';\nimport {LocalRefExtractor, TAttributes, TContainerNode, TNode, TNodeType} from '../interfaces/node';\nimport {RComment} from '../interfaces/renderer_dom';\nimport {isDirectiveHost} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, HYDRATION, LView, RENDERER, TView, TViewType} from '../interfaces/view';\nimport {appendChild} from '../node_manipulation';\nimport {getLView, getTView, isInSkipHydrationBlock, lastNodeWasCreated, setCurrentTNode, wasLastNodeCreated} from '../state';\nimport {getConstant} from '../util/view_utils';\n\nimport {addToViewTree, createDirectivesInstances, createLContainer, createTView, getOrCreateTNode, resolveDirectives, saveResolvedLocalsInData} from './shared';\n\nfunction templateFirstCreatePass(\n    index: number, tView: TView, lView: LView, templateFn: ComponentTemplate<any>|null,\n    decls: number, vars: number, tagName?: string|null, attrsIndex?: number|null,\n    localRefsIndex?: number|null): TContainerNode {\n  ngDevMode && assertFirstCreatePass(tView);\n  ngDevMode && ngDevMode.firstCreatePass++;\n  const tViewConsts = tView.consts;\n\n  // TODO(pk): refactor getOrCreateTNode to have the \"create\" only version\n  const tNode = getOrCreateTNode(\n      tView, index, TNodeType.Container, tagName || null,\n      getConstant<TAttributes>(tViewConsts, attrsIndex));\n\n  resolveDirectives(tView, lView, tNode, getConstant<string[]>(tViewConsts, localRefsIndex));\n  registerPostOrderHooks(tView, tNode);\n\n  const embeddedTView = tNode.tView = createTView(\n      TViewType.Embedded, tNode, templateFn, decls, vars, tView.directiveRegistry,\n      tView.pipeRegistry, null, tView.schemas, tViewConsts, null /* ssrId */);\n\n  if (tView.queries !== null) {\n    tView.queries.template(tView, tNode);\n    embeddedTView.queries = tView.queries.embeddedTView(tNode);\n  }\n\n  return tNode;\n}\n\n/**\n * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.\n *\n * <ng-template #foo>\n *    <div></div>\n * </ng-template>\n *\n * @param index The index of the container in the data array\n * @param templateFn Inline template\n * @param decls The number of nodes, local refs, and pipes for this template\n * @param vars The number of bindings for this template\n * @param tagName The name of the container element, if applicable\n * @param attrsIndex Index of template attributes in the `consts` array.\n * @param localRefs Index of the local references in the `consts` array.\n * @param localRefExtractor A function which extracts local-refs values from the template.\n *        Defaults to the current element associated with the local-ref.\n *\n * @codeGenApi\n */\nexport function ɵɵtemplate(\n    index: number, templateFn: ComponentTemplate<any>|null, decls: number, vars: number,\n    tagName?: string|null, attrsIndex?: number|null, localRefsIndex?: number|null,\n    localRefExtractor?: LocalRefExtractor) {\n  const lView = getLView();\n  const tView = getTView();\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  const tNode = tView.firstCreatePass ? templateFirstCreatePass(\n                                            adjustedIndex, tView, lView, templateFn, decls, vars,\n                                            tagName, attrsIndex, localRefsIndex) :\n                                        tView.data[adjustedIndex] as TContainerNode;\n  setCurrentTNode(tNode, false);\n\n  const comment = _locateOrCreateContainerAnchor(tView, lView, tNode, index) as RComment;\n\n  if (wasLastNodeCreated()) {\n    appendChild(tView, lView, comment, tNode);\n  }\n  attachPatchData(comment, lView);\n\n  addToViewTree(lView, lView[adjustedIndex] = createLContainer(comment, lView, comment, tNode));\n\n  if (isDirectiveHost(tNode)) {\n    createDirectivesInstances(tView, lView, tNode);\n  }\n\n  if (localRefsIndex != null) {\n    saveResolvedLocalsInData(lView, tNode, localRefExtractor);\n  }\n}\n\nlet _locateOrCreateContainerAnchor = createContainerAnchorImpl;\n\n/**\n * Regular creation mode for LContainers and their anchor (comment) nodes.\n */\nfunction createContainerAnchorImpl(\n    tView: TView, lView: LView, tNode: TNode, index: number): RComment {\n  lastNodeWasCreated(true);\n  return lView[RENDERER].createComment(ngDevMode ? 'container' : '');\n}\n\n/**\n * Enables hydration code path (to lookup existing elements in DOM)\n * in addition to the regular creation mode for LContainers and their\n * anchor (comment) nodes.\n */\nfunction locateOrCreateContainerAnchorImpl(\n    tView: TView, lView: LView, tNode: TNode, index: number): RComment {\n  const hydrationInfo = lView[HYDRATION];\n  const isNodeCreationMode =\n      !hydrationInfo || isInSkipHydrationBlock() || isDisconnectedNode(hydrationInfo, index);\n  lastNodeWasCreated(isNodeCreationMode);\n\n  // Regular creation mode.\n  if (isNodeCreationMode) {\n    return createContainerAnchorImpl(tView, lView, tNode, index);\n  }\n\n  const ssrId = hydrationInfo.data[TEMPLATES]?.[index] ?? null;\n\n  // Apply `ssrId` value to the underlying TView if it was not previously set.\n  //\n  // There might be situations when the same component is present in a template\n  // multiple times and some instances are opted-out of using hydration via\n  // `ngSkipHydration` attribute. In this scenario, at the time a TView is created,\n  // the `ssrId` might be `null` (if the first component is opted-out of hydration).\n  // The code below makes sure that the `ssrId` is applied to the TView if it's still\n  // `null` and verifies we never try to override it with a different value.\n  if (ssrId !== null && tNode.tView !== null) {\n    if (tNode.tView.ssrId === null) {\n      tNode.tView.ssrId = ssrId;\n    } else {\n      ngDevMode &&\n          assertEqual(tNode.tView.ssrId, ssrId, 'Unexpected value of the `ssrId` for this TView');\n    }\n  }\n\n  // Hydration mode, looking up existing elements in DOM.\n  const currentRNode = locateNextRNode(hydrationInfo, tView, lView, tNode)!;\n  ngDevMode && validateNodeExists(currentRNode, lView, tNode);\n\n  setSegmentHead(hydrationInfo, index, currentRNode);\n  const viewContainerSize = calcSerializedContainerSize(hydrationInfo, index);\n  const comment = siblingAfter<RComment>(viewContainerSize, currentRNode)!;\n\n  if (ngDevMode) {\n    validateMatchingNode(comment, Node.COMMENT_NODE, null, lView, tNode);\n    markRNodeAsClaimedByHydration(comment);\n  }\n\n  return comment;\n}\n\nexport function enableLocateOrCreateContainerAnchorImpl() {\n  _locateOrCreateContainerAnchor = locateOrCreateContainerAnchorImpl;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAC,oBAAoB,EAAE,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AACxF,OAAO,EAAC,SAAS,EAAC,MAAM,4BAA4B,CAAC;AACrD,OAAO,EAAC,eAAe,EAAE,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAC,2BAA2B,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACrI,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAC,qBAAqB,EAAC,MAAM,WAAW,CAAC;AAChD,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAC,sBAAsB,EAAC,MAAM,UAAU,CAAC;AAIhD,OAAO,EAAC,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAC,aAAa,EAAE,SAAS,EAAS,QAAQ,EAAmB,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,eAAe,EAAE,kBAAkB,EAAC,MAAM,UAAU,CAAC;AAC7H,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAC,aAAa,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAC,MAAM,UAAU,CAAC;AAEhK,SAAS,uBAAuB,CAC5B,KAAa,EAAE,KAAY,EAAE,KAAY,EAAE,UAAuC,EAClF,KAAa,EAAE,IAAY,EAAE,OAAqB,EAAE,UAAwB,EAC5E,cAA4B;IAC9B,SAAS,IAAI,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC1C,SAAS,IAAI,SAAS,CAAC,eAAe,EAAE,CAAC;IACzC,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC;IAEjC,wEAAwE;IACxE,MAAM,KAAK,GAAG,gBAAgB,CAC1B,KAAK,EAAE,KAAK,+BAAuB,OAAO,IAAI,IAAI,EAClD,WAAW,CAAc,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;IAEvD,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,CAAW,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;IAC3F,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAErC,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,GAAG,WAAW,6BACvB,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,iBAAiB,EAC3E,KAAK,CAAC,YAAY,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAE5E,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,EAAE;QAC1B,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrC,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;KAC5D;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,UAAU,CACtB,KAAa,EAAE,UAAuC,EAAE,KAAa,EAAE,IAAY,EACnF,OAAqB,EAAE,UAAwB,EAAE,cAA4B,EAC7E,iBAAqC;IACvC,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,aAAa,GAAG,KAAK,GAAG,aAAa,CAAC;IAE5C,MAAM,KAAK,GAAG,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,uBAAuB,CACnB,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EACpD,OAAO,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;QAC1C,KAAK,CAAC,IAAI,CAAC,aAAa,CAAmB,CAAC;IAClF,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAE9B,MAAM,OAAO,GAAG,8BAA8B,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAa,CAAC;IAEvF,IAAI,kBAAkB,EAAE,EAAE;QACxB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;KAC3C;IACD,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAEhC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;IAE9F,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE;QAC1B,yBAAyB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;KAChD;IAED,IAAI,cAAc,IAAI,IAAI,EAAE;QAC1B,wBAAwB,CAAC,KAAK,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;KAC3D;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,IAAI,8BAA8B,GAAG,yBAAyB,CAAC;AAE/D;;GAEG;AACH,SAAS,yBAAyB,CAC9B,KAAY,EAAE,KAAY,EAAE,KAAY,EAAE,KAAa;IACzD,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AACrE,CAAC;AAED;;;;GAIG;AACH,SAAS,iCAAiC,CACtC,KAAY,EAAE,KAAY,EAAE,KAAY,EAAE,KAAa;IACzD,MAAM,aAAa,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IACvC,MAAM,kBAAkB,GACpB,CAAC,aAAa,IAAI,sBAAsB,EAAE,IAAI,kBAAkB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAC3F,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;IAEvC,yBAAyB;IACzB,IAAI,kBAAkB,EAAE;QACtB,OAAO,yBAAyB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;KAC9D;IAED,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;IAE7D,4EAA4E;IAC5E,EAAE;IACF,6EAA6E;IAC7E,yEAAyE;IACzE,iFAAiF;IACjF,kFAAkF;IAClF,mFAAmF;IACnF,0EAA0E;IAC1E,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,EAAE;QAC1C,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,EAAE;YAC9B,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;SAC3B;aAAM;YACL,SAAS;gBACL,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,gDAAgD,CAAC,CAAC;SAC7F;KACF;IAED,uDAAuD;IACvD,MAAM,YAAY,GAAG,eAAe,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAE,CAAC;IAC1E,SAAS,IAAI,kBAAkB,CAAC,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAE5D,cAAc,CAAC,aAAa,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IACnD,MAAM,iBAAiB,GAAG,2BAA2B,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IAC5E,MAAM,OAAO,GAAG,YAAY,CAAW,iBAAiB,EAAE,YAAY,CAAE,CAAC;IAEzE,IAAI,SAAS,EAAE;QACb,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QACrE,6BAA6B,CAAC,OAAO,CAAC,CAAC;KACxC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,uCAAuC;IACrD,8BAA8B,GAAG,iCAAiC,CAAC;AACrE,CAAC","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.io/license\n */\nimport {validateMatchingNode, validateNodeExists} from '../../hydration/error_handling';\nimport {TEMPLATES} from '../../hydration/interfaces';\nimport {locateNextRNode, siblingAfter} from '../../hydration/node_lookup_utils';\nimport {calcSerializedContainerSize, isDisconnectedNode, markRNodeAsClaimedByHydration, setSegmentHead} from '../../hydration/utils';\nimport {assertEqual} from '../../util/assert';\nimport {assertFirstCreatePass} from '../assert';\nimport {attachPatchData} from '../context_discovery';\nimport {registerPostOrderHooks} from '../hooks';\nimport {ComponentTemplate} from '../interfaces/definition';\nimport {LocalRefExtractor, TAttributes, TContainerNode, TNode, TNodeType} from '../interfaces/node';\nimport {RComment} from '../interfaces/renderer_dom';\nimport {isDirectiveHost} from '../interfaces/type_checks';\nimport {HEADER_OFFSET, HYDRATION, LView, RENDERER, TView, TViewType} from '../interfaces/view';\nimport {appendChild} from '../node_manipulation';\nimport {getLView, getTView, isInSkipHydrationBlock, lastNodeWasCreated, setCurrentTNode, wasLastNodeCreated} from '../state';\nimport {getConstant} from '../util/view_utils';\n\nimport {addToViewTree, createDirectivesInstances, createLContainer, createTView, getOrCreateTNode, resolveDirectives, saveResolvedLocalsInData} from './shared';\n\nfunction templateFirstCreatePass(\n    index: number, tView: TView, lView: LView, templateFn: ComponentTemplate<any>|null,\n    decls: number, vars: number, tagName?: string|null, attrsIndex?: number|null,\n    localRefsIndex?: number|null): TContainerNode {\n  ngDevMode && assertFirstCreatePass(tView);\n  ngDevMode && ngDevMode.firstCreatePass++;\n  const tViewConsts = tView.consts;\n\n  // TODO(pk): refactor getOrCreateTNode to have the \"create\" only version\n  const tNode = getOrCreateTNode(\n      tView, index, TNodeType.Container, tagName || null,\n      getConstant<TAttributes>(tViewConsts, attrsIndex));\n\n  resolveDirectives(tView, lView, tNode, getConstant<string[]>(tViewConsts, localRefsIndex));\n  registerPostOrderHooks(tView, tNode);\n\n  const embeddedTView = tNode.tView = createTView(\n      TViewType.Embedded, tNode, templateFn, decls, vars, tView.directiveRegistry,\n      tView.pipeRegistry, null, tView.schemas, tViewConsts, null /* ssrId */);\n\n  if (tView.queries !== null) {\n    tView.queries.template(tView, tNode);\n    embeddedTView.queries = tView.queries.embeddedTView(tNode);\n  }\n\n  return tNode;\n}\n\n/**\n * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.\n *\n * <ng-template #foo>\n *    <div></div>\n * </ng-template>\n *\n * @param index The index of the container in the data array\n * @param templateFn Inline template\n * @param decls The number of nodes, local refs, and pipes for this template\n * @param vars The number of bindings for this template\n * @param tagName The name of the container element, if applicable\n * @param attrsIndex Index of template attributes in the `consts` array.\n * @param localRefs Index of the local references in the `consts` array.\n * @param localRefExtractor A function which extracts local-refs values from the template.\n *        Defaults to the current element associated with the local-ref.\n *\n * @codeGenApi\n */\nexport function ɵɵtemplate(\n    index: number, templateFn: ComponentTemplate<any>|null, decls: number, vars: number,\n    tagName?: string|null, attrsIndex?: number|null, localRefsIndex?: number|null,\n    localRefExtractor?: LocalRefExtractor): typeof ɵɵtemplate {\n  const lView = getLView();\n  const tView = getTView();\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  const tNode = tView.firstCreatePass ? templateFirstCreatePass(\n                                            adjustedIndex, tView, lView, templateFn, decls, vars,\n                                            tagName, attrsIndex, localRefsIndex) :\n                                        tView.data[adjustedIndex] as TContainerNode;\n  setCurrentTNode(tNode, false);\n\n  const comment = _locateOrCreateContainerAnchor(tView, lView, tNode, index) as RComment;\n\n  if (wasLastNodeCreated()) {\n    appendChild(tView, lView, comment, tNode);\n  }\n  attachPatchData(comment, lView);\n\n  addToViewTree(lView, lView[adjustedIndex] = createLContainer(comment, lView, comment, tNode));\n\n  if (isDirectiveHost(tNode)) {\n    createDirectivesInstances(tView, lView, tNode);\n  }\n\n  if (localRefsIndex != null) {\n    saveResolvedLocalsInData(lView, tNode, localRefExtractor);\n  }\n\n  return ɵɵtemplate;\n}\n\nlet _locateOrCreateContainerAnchor = createContainerAnchorImpl;\n\n/**\n * Regular creation mode for LContainers and their anchor (comment) nodes.\n */\nfunction createContainerAnchorImpl(\n    tView: TView, lView: LView, tNode: TNode, index: number): RComment {\n  lastNodeWasCreated(true);\n  return lView[RENDERER].createComment(ngDevMode ? 'container' : '');\n}\n\n/**\n * Enables hydration code path (to lookup existing elements in DOM)\n * in addition to the regular creation mode for LContainers and their\n * anchor (comment) nodes.\n */\nfunction locateOrCreateContainerAnchorImpl(\n    tView: TView, lView: LView, tNode: TNode, index: number): RComment {\n  const hydrationInfo = lView[HYDRATION];\n  const isNodeCreationMode =\n      !hydrationInfo || isInSkipHydrationBlock() || isDisconnectedNode(hydrationInfo, index);\n  lastNodeWasCreated(isNodeCreationMode);\n\n  // Regular creation mode.\n  if (isNodeCreationMode) {\n    return createContainerAnchorImpl(tView, lView, tNode, index);\n  }\n\n  const ssrId = hydrationInfo.data[TEMPLATES]?.[index] ?? null;\n\n  // Apply `ssrId` value to the underlying TView if it was not previously set.\n  //\n  // There might be situations when the same component is present in a template\n  // multiple times and some instances are opted-out of using hydration via\n  // `ngSkipHydration` attribute. In this scenario, at the time a TView is created,\n  // the `ssrId` might be `null` (if the first component is opted-out of hydration).\n  // The code below makes sure that the `ssrId` is applied to the TView if it's still\n  // `null` and verifies we never try to override it with a different value.\n  if (ssrId !== null && tNode.tView !== null) {\n    if (tNode.tView.ssrId === null) {\n      tNode.tView.ssrId = ssrId;\n    } else {\n      ngDevMode &&\n          assertEqual(tNode.tView.ssrId, ssrId, 'Unexpected value of the `ssrId` for this TView');\n    }\n  }\n\n  // Hydration mode, looking up existing elements in DOM.\n  const currentRNode = locateNextRNode(hydrationInfo, tView, lView, tNode)!;\n  ngDevMode && validateNodeExists(currentRNode, lView, tNode);\n\n  setSegmentHead(hydrationInfo, index, currentRNode);\n  const viewContainerSize = calcSerializedContainerSize(hydrationInfo, index);\n  const comment = siblingAfter<RComment>(viewContainerSize, currentRNode)!;\n\n  if (ngDevMode) {\n    validateMatchingNode(comment, Node.COMMENT_NODE, null, lView, tNode);\n    markRNodeAsClaimedByHydration(comment);\n  }\n\n  return comment;\n}\n\nexport function enableLocateOrCreateContainerAnchorImpl() {\n  _locateOrCreateContainerAnchor = locateOrCreateContainerAnchorImpl;\n}\n"]}

package/esm2022/src/render3/interfaces/defer.mjs

@@ -0,0 +1,9 @@
+/**
+ * @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.io/license
+ */
+export const DEFER_BLOCK_STATE = 0;
+//# sourceMappingURL=data:application/json;base64,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