@angular/core
Version:
Angular - the core framework
278 lines • 41.1 kB
JavaScript
/**
* @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
*/
import { setActiveConsumer } from '@angular/core/primitives/signals';
import { findMatchingDehydratedView } from '../../hydration/views';
import { assertDefined } from '../../util/assert';
import { performanceMark } from '../../util/performance';
import { assertLContainer, assertLView, assertTNode } from '../assert';
import { bindingUpdated } from '../bindings';
import { CONTAINER_HEADER_OFFSET } from '../interfaces/container';
import { CONTEXT, DECLARATION_COMPONENT_VIEW, HEADER_OFFSET, HYDRATION, TVIEW } from '../interfaces/view';
import { LiveCollection, reconcile } from '../list_reconciliation';
import { destroyLView, detachView } from '../node_manipulation';
import { getLView, nextBindingIndex } from '../state';
import { getTNode } from '../util/view_utils';
import { addLViewToLContainer, createAndRenderEmbeddedLView, getLViewFromLContainer, removeLViewFromLContainer, shouldAddViewToDom } from '../view_manipulation';
import { ɵɵtemplate } from './template';
const PERF_MARK_CONTROL_FLOW = {
detail: { feature: 'NgControlFlow' }
};
/**
* The conditional instruction represents the basic building block on the runtime side to support
* built-in "if" and "switch". On the high level this instruction is responsible for adding and
* removing views selected by a conditional expression.
*
* @param containerIndex index of a container in a host view (indexed from HEADER_OFFSET) where
* conditional views should be inserted.
* @param matchingTemplateIndex index of a template TNode representing a conditional view to be
* inserted; -1 represents a special case when there is no view to insert.
* @codeGenApi
*/
export function ɵɵconditional(containerIndex, matchingTemplateIndex, value) {
performanceMark('mark_use_counter', PERF_MARK_CONTROL_FLOW);
const hostLView = getLView();
const bindingIndex = nextBindingIndex();
const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
const viewInContainerIdx = 0;
if (bindingUpdated(hostLView, bindingIndex, matchingTemplateIndex)) {
const prevConsumer = setActiveConsumer(null);
try {
// The index of the view to show changed - remove the previously displayed one
// (it is a noop if there are no active views in a container).
removeLViewFromLContainer(lContainer, viewInContainerIdx);
// Index -1 is a special case where none of the conditions evaluates to
// a truthy value and as the consequence we've got no view to show.
if (matchingTemplateIndex !== -1) {
const templateTNode = getExistingTNode(hostLView[TVIEW], matchingTemplateIndex);
const dehydratedView = findMatchingDehydratedView(lContainer, templateTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(hostLView, templateTNode, value, { dehydratedView });
addLViewToLContainer(lContainer, embeddedLView, viewInContainerIdx, shouldAddViewToDom(templateTNode, dehydratedView));
}
}
finally {
setActiveConsumer(prevConsumer);
}
}
else {
// We might keep displaying the same template but the actual value of the expression could have
// changed - re-bind in context.
const lView = getLViewFromLContainer(lContainer, viewInContainerIdx);
if (lView !== undefined) {
lView[CONTEXT] = value;
}
}
}
export class RepeaterContext {
constructor(lContainer, $implicit, $index) {
this.lContainer = lContainer;
this.$implicit = $implicit;
this.$index = $index;
}
get $count() {
return this.lContainer.length - CONTAINER_HEADER_OFFSET;
}
}
/**
* A built-in trackBy function used for situations where users specified collection index as a
* tracking expression. Having this function body in the runtime avoids unnecessary code generation.
*
* @param index
* @returns
*/
export function ɵɵrepeaterTrackByIndex(index) {
return index;
}
/**
* A built-in trackBy function used for situations where users specified collection item reference
* as a tracking expression. Having this function body in the runtime avoids unnecessary code
* generation.
*
* @param index
* @returns
*/
export function ɵɵrepeaterTrackByIdentity(_, value) {
return value;
}
class RepeaterMetadata {
constructor(hasEmptyBlock, trackByFn, liveCollection) {
this.hasEmptyBlock = hasEmptyBlock;
this.trackByFn = trackByFn;
this.liveCollection = liveCollection;
}
}
/**
* The repeaterCreate instruction runs in the creation part of the template pass and initializes
* internal data structures required by the update pass of the built-in repeater logic. Repeater
* metadata are allocated in the data part of LView with the following layout:
* - LView[HEADER_OFFSET + index] - metadata
* - LView[HEADER_OFFSET + index + 1] - reference to a template function rendering an item
* - LView[HEADER_OFFSET + index + 2] - optional reference to a template function rendering an empty
* block
*
* @param index Index at which to store the metadata of the repeater.
* @param templateFn Reference to the template of the main repeater block.
* @param decls The number of nodes, local refs, and pipes for the main block.
* @param vars The number of bindings for the main block.
* @param tagName The name of the container element, if applicable
* @param attrsIndex Index of template attributes in the `consts` array.
* @param trackByFn Reference to the tracking function.
* @param trackByUsesComponentInstance Whether the tracking function has any references to the
* component instance. If it doesn't, we can avoid rebinding it.
* @param emptyTemplateFn Reference to the template function of the empty block.
* @param emptyDecls The number of nodes, local refs, and pipes for the empty block.
* @param emptyVars The number of bindings for the empty block.
*
* @codeGenApi
*/
export function ɵɵrepeaterCreate(index, templateFn, decls, vars, tagName, attrsIndex, trackByFn, trackByUsesComponentInstance, emptyTemplateFn, emptyDecls, emptyVars) {
performanceMark('mark_use_counter', PERF_MARK_CONTROL_FLOW);
const hasEmptyBlock = emptyTemplateFn !== undefined;
const hostLView = getLView();
const boundTrackBy = trackByUsesComponentInstance ?
// We only want to bind when necessary, because it produces a
// new function. For pure functions it's not necessary.
trackByFn.bind(hostLView[DECLARATION_COMPONENT_VIEW][CONTEXT]) :
trackByFn;
const metadata = new RepeaterMetadata(hasEmptyBlock, boundTrackBy);
hostLView[HEADER_OFFSET + index] = metadata;
ɵɵtemplate(index + 1, templateFn, decls, vars, tagName, attrsIndex);
if (hasEmptyBlock) {
ngDevMode &&
assertDefined(emptyDecls, 'Missing number of declarations for the empty repeater block.');
ngDevMode &&
assertDefined(emptyVars, 'Missing number of bindings for the empty repeater block.');
ɵɵtemplate(index + 2, emptyTemplateFn, emptyDecls, emptyVars);
}
}
class LiveCollectionLContainerImpl extends LiveCollection {
constructor(lContainer, hostLView, templateTNode) {
super();
this.lContainer = lContainer;
this.hostLView = hostLView;
this.templateTNode = templateTNode;
/**
Property indicating if indexes in the repeater context need to be updated following the live
collection changes. Index updates are necessary if and only if views are inserted / removed in
the middle of LContainer. Adds and removals at the end don't require index updates.
*/
this.needsIndexUpdate = false;
}
get length() {
return this.lContainer.length - CONTAINER_HEADER_OFFSET;
}
at(index) {
return this.getLView(index)[CONTEXT].$implicit;
}
attach(index, lView) {
const dehydratedView = lView[HYDRATION];
this.needsIndexUpdate ||= index !== this.length;
addLViewToLContainer(this.lContainer, lView, index, shouldAddViewToDom(this.templateTNode, dehydratedView));
}
detach(index) {
this.needsIndexUpdate ||= index !== this.length - 1;
return detachExistingView(this.lContainer, index);
}
create(index, value) {
const dehydratedView = findMatchingDehydratedView(this.lContainer, this.templateTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(this.hostLView, this.templateTNode, new RepeaterContext(this.lContainer, value, index), { dehydratedView });
return embeddedLView;
}
destroy(lView) {
destroyLView(lView[TVIEW], lView);
}
updateValue(index, value) {
this.getLView(index)[CONTEXT].$implicit = value;
}
reset() {
this.needsIndexUpdate = false;
}
updateIndexes() {
if (this.needsIndexUpdate) {
for (let i = 0; i < this.length; i++) {
this.getLView(i)[CONTEXT].$index = i;
}
}
}
getLView(index) {
return getExistingLViewFromLContainer(this.lContainer, index);
}
}
/**
* The repeater instruction does update-time diffing of a provided collection (against the
* collection seen previously) and maps changes in the collection to views structure (by adding,
* removing or moving views as needed).
* @param metadataSlotIdx - index in data where we can find an instance of RepeaterMetadata with
* additional information (ex. differ) needed to process collection diffing and view
* manipulation
* @param collection - the collection instance to be checked for changes
* @codeGenApi
*/
export function ɵɵrepeater(metadataSlotIdx, collection) {
const prevConsumer = setActiveConsumer(null);
try {
const hostLView = getLView();
const hostTView = hostLView[TVIEW];
const metadata = hostLView[HEADER_OFFSET + metadataSlotIdx];
if (metadata.liveCollection === undefined) {
const containerIndex = metadataSlotIdx + 1;
const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
metadata.liveCollection =
new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);
}
else {
metadata.liveCollection.reset();
}
const liveCollection = metadata.liveCollection;
reconcile(liveCollection, collection, metadata.trackByFn);
// moves in the container might caused context's index to get out of order, re-adjust if needed
liveCollection.updateIndexes();
// handle empty blocks
if (metadata.hasEmptyBlock) {
const bindingIndex = nextBindingIndex();
const isCollectionEmpty = liveCollection.length === 0;
if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {
const emptyTemplateIndex = metadataSlotIdx + 2;
const lContainerForEmpty = getLContainer(hostLView, HEADER_OFFSET + emptyTemplateIndex);
if (isCollectionEmpty) {
const emptyTemplateTNode = getExistingTNode(hostTView, emptyTemplateIndex);
const dehydratedView = findMatchingDehydratedView(lContainerForEmpty, emptyTemplateTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(hostLView, emptyTemplateTNode, undefined, { dehydratedView });
addLViewToLContainer(lContainerForEmpty, embeddedLView, 0, shouldAddViewToDom(emptyTemplateTNode, dehydratedView));
}
else {
removeLViewFromLContainer(lContainerForEmpty, 0);
}
}
}
}
finally {
setActiveConsumer(prevConsumer);
}
}
function getLContainer(lView, index) {
const lContainer = lView[index];
ngDevMode && assertLContainer(lContainer);
return lContainer;
}
function detachExistingView(lContainer, index) {
const existingLView = detachView(lContainer, index);
ngDevMode && assertLView(existingLView);
return existingLView;
}
function getExistingLViewFromLContainer(lContainer, index) {
const existingLView = getLViewFromLContainer(lContainer, index);
ngDevMode && assertLView(existingLView);
return existingLView;
}
function getExistingTNode(tView, index) {
const tNode = getTNode(tView, index + HEADER_OFFSET);
ngDevMode && assertTNode(tNode);
return tNode;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"control_flow.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/control_flow.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 */\n\nimport {setActiveConsumer} from '@angular/core/primitives/signals';\n\nimport {TrackByFunction} from '../../change_detection';\nimport {DehydratedContainerView} from '../../hydration/interfaces';\nimport {findMatchingDehydratedView} from '../../hydration/views';\nimport {assertDefined} from '../../util/assert';\nimport {performanceMark} from '../../util/performance';\nimport {assertLContainer, assertLView, assertTNode} from '../assert';\nimport {bindingUpdated} from '../bindings';\nimport {CONTAINER_HEADER_OFFSET, LContainer} from '../interfaces/container';\nimport {ComponentTemplate} from '../interfaces/definition';\nimport {TNode} from '../interfaces/node';\nimport {CONTEXT, DECLARATION_COMPONENT_VIEW, HEADER_OFFSET, HYDRATION, LView, TVIEW, TView} from '../interfaces/view';\nimport {LiveCollection, reconcile} from '../list_reconciliation';\nimport {destroyLView, detachView} from '../node_manipulation';\nimport {getLView, nextBindingIndex} from '../state';\nimport {getTNode} from '../util/view_utils';\nimport {addLViewToLContainer, createAndRenderEmbeddedLView, getLViewFromLContainer, removeLViewFromLContainer, shouldAddViewToDom} from '../view_manipulation';\n\nimport {ɵɵtemplate} from './template';\n\nconst PERF_MARK_CONTROL_FLOW = {\n  detail: {feature: 'NgControlFlow'}\n};\n\n/**\n * The conditional instruction represents the basic building block on the runtime side to support\n * built-in \"if\" and \"switch\". On the high level this instruction is responsible for adding and\n * removing views selected by a conditional expression.\n *\n * @param containerIndex index of a container in a host view (indexed from HEADER_OFFSET) where\n *     conditional views should be inserted.\n * @param matchingTemplateIndex index of a template TNode representing a conditional view to be\n *     inserted; -1 represents a special case when there is no view to insert.\n * @codeGenApi\n */\nexport function ɵɵconditional<T>(containerIndex: number, matchingTemplateIndex: number, value?: T) {\n  performanceMark('mark_use_counter', PERF_MARK_CONTROL_FLOW);\n\n  const hostLView = getLView();\n  const bindingIndex = nextBindingIndex();\n  const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);\n  const viewInContainerIdx = 0;\n\n  if (bindingUpdated(hostLView, bindingIndex, matchingTemplateIndex)) {\n    const prevConsumer = setActiveConsumer(null);\n    try {\n      // The index of the view to show changed - remove the previously displayed one\n      // (it is a noop if there are no active views in a container).\n      removeLViewFromLContainer(lContainer, viewInContainerIdx);\n\n      // Index -1 is a special case where none of the conditions evaluates to\n      // a truthy value and as the consequence we've got no view to show.\n      if (matchingTemplateIndex !== -1) {\n        const templateTNode = getExistingTNode(hostLView[TVIEW], matchingTemplateIndex);\n\n        const dehydratedView = findMatchingDehydratedView(lContainer, templateTNode.tView!.ssrId);\n        const embeddedLView =\n            createAndRenderEmbeddedLView(hostLView, templateTNode, value, {dehydratedView});\n\n        addLViewToLContainer(\n            lContainer, embeddedLView, viewInContainerIdx,\n            shouldAddViewToDom(templateTNode, dehydratedView));\n      }\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n  } else {\n    // We might keep displaying the same template but the actual value of the expression could have\n    // changed - re-bind in context.\n    const lView = getLViewFromLContainer<T|undefined>(lContainer, viewInContainerIdx);\n    if (lView !== undefined) {\n      lView[CONTEXT] = value;\n    }\n  }\n}\n\nexport class RepeaterContext<T> {\n  constructor(private lContainer: LContainer, public $implicit: T, public $index: number) {}\n\n  get $count(): number {\n    return this.lContainer.length - CONTAINER_HEADER_OFFSET;\n  }\n}\n\n/**\n * A built-in trackBy function used for situations where users specified collection index as a\n * tracking expression. Having this function body in the runtime avoids unnecessary code generation.\n *\n * @param index\n * @returns\n */\nexport function ɵɵrepeaterTrackByIndex(index: number) {\n  return index;\n}\n\n/**\n * A built-in trackBy function used for situations where users specified collection item reference\n * as a tracking expression. Having this function body in the runtime avoids unnecessary code\n * generation.\n *\n * @param index\n * @returns\n */\nexport function ɵɵrepeaterTrackByIdentity<T>(_: number, value: T) {\n  return value;\n}\n\nclass RepeaterMetadata {\n  constructor(\n      public hasEmptyBlock: boolean, public trackByFn: TrackByFunction<unknown>,\n      public liveCollection?: LiveCollectionLContainerImpl) {}\n}\n\n/**\n * The repeaterCreate instruction runs in the creation part of the template pass and initializes\n * internal data structures required by the update pass of the built-in repeater logic. Repeater\n * metadata are allocated in the data part of LView with the following layout:\n * - LView[HEADER_OFFSET + index] - metadata\n * - LView[HEADER_OFFSET + index + 1] - reference to a template function rendering an item\n * - LView[HEADER_OFFSET + index + 2] - optional reference to a template function rendering an empty\n * block\n *\n * @param index Index at which to store the metadata of the repeater.\n * @param templateFn Reference to the template of the main repeater block.\n * @param decls The number of nodes, local refs, and pipes for the main block.\n * @param vars The number of bindings for the main block.\n * @param tagName The name of the container element, if applicable\n * @param attrsIndex Index of template attributes in the `consts` array.\n * @param trackByFn Reference to the tracking function.\n * @param trackByUsesComponentInstance Whether the tracking function has any references to the\n *  component instance. If it doesn't, we can avoid rebinding it.\n * @param emptyTemplateFn Reference to the template function of the empty block.\n * @param emptyDecls The number of nodes, local refs, and pipes for the empty block.\n * @param emptyVars The number of bindings for the empty block.\n *\n * @codeGenApi\n */\nexport function ɵɵrepeaterCreate(\n    index: number, templateFn: ComponentTemplate<unknown>, decls: number, vars: number,\n    tagName: string|null, attrsIndex: number|null, trackByFn: TrackByFunction<unknown>,\n    trackByUsesComponentInstance?: boolean, emptyTemplateFn?: ComponentTemplate<unknown>,\n    emptyDecls?: number, emptyVars?: number): void {\n  performanceMark('mark_use_counter', PERF_MARK_CONTROL_FLOW);\n  const hasEmptyBlock = emptyTemplateFn !== undefined;\n  const hostLView = getLView();\n  const boundTrackBy = trackByUsesComponentInstance ?\n      // We only want to bind when necessary, because it produces a\n      // new function. For pure functions it's not necessary.\n      trackByFn.bind(hostLView[DECLARATION_COMPONENT_VIEW][CONTEXT]) :\n      trackByFn;\n  const metadata = new RepeaterMetadata(hasEmptyBlock, boundTrackBy);\n  hostLView[HEADER_OFFSET + index] = metadata;\n\n  ɵɵtemplate(index + 1, templateFn, decls, vars, tagName, attrsIndex);\n\n  if (hasEmptyBlock) {\n    ngDevMode &&\n        assertDefined(emptyDecls, 'Missing number of declarations for the empty repeater block.');\n    ngDevMode &&\n        assertDefined(emptyVars, 'Missing number of bindings for the empty repeater block.');\n\n    ɵɵtemplate(index + 2, emptyTemplateFn, emptyDecls!, emptyVars!);\n  }\n}\n\nclass LiveCollectionLContainerImpl extends\n    LiveCollection<LView<RepeaterContext<unknown>>, unknown> {\n  /**\n   Property indicating if indexes in the repeater context need to be updated following the live\n   collection changes. Index updates are necessary if and only if views are inserted / removed in\n   the middle of LContainer. Adds and removals at the end don't require index updates.\n */\n  private needsIndexUpdate = false;\n  constructor(\n      private lContainer: LContainer, private hostLView: LView, private templateTNode: TNode) {\n    super();\n  }\n\n  override get length(): number {\n    return this.lContainer.length - CONTAINER_HEADER_OFFSET;\n  }\n  override at(index: number): unknown {\n    return this.getLView(index)[CONTEXT].$implicit;\n  }\n  override attach(index: number, lView: LView<RepeaterContext<unknown>>): void {\n    const dehydratedView = lView[HYDRATION] as DehydratedContainerView;\n    this.needsIndexUpdate ||= index !== this.length;\n    addLViewToLContainer(\n        this.lContainer, lView, index, shouldAddViewToDom(this.templateTNode, dehydratedView));\n  }\n  override detach(index: number): LView<RepeaterContext<unknown>> {\n    this.needsIndexUpdate ||= index !== this.length - 1;\n    return detachExistingView<RepeaterContext<unknown>>(this.lContainer, index);\n  }\n  override create(index: number, value: unknown): LView<RepeaterContext<unknown>> {\n    const dehydratedView =\n        findMatchingDehydratedView(this.lContainer, this.templateTNode.tView!.ssrId);\n    const embeddedLView = createAndRenderEmbeddedLView(\n        this.hostLView, this.templateTNode, new RepeaterContext(this.lContainer, value, index),\n        {dehydratedView});\n\n    return embeddedLView;\n  }\n  override destroy(lView: LView<RepeaterContext<unknown>>): void {\n    destroyLView(lView[TVIEW], lView);\n  }\n  override updateValue(index: number, value: unknown): void {\n    this.getLView(index)[CONTEXT].$implicit = value;\n  }\n\n  reset() {\n    this.needsIndexUpdate = false;\n  }\n\n  updateIndexes() {\n    if (this.needsIndexUpdate) {\n      for (let i = 0; i < this.length; i++) {\n        this.getLView(i)[CONTEXT].$index = i;\n      }\n    }\n  }\n\n  private getLView(index: number): LView<RepeaterContext<unknown>> {\n    return getExistingLViewFromLContainer(this.lContainer, index);\n  }\n}\n\n/**\n * The repeater instruction does update-time diffing of a provided collection (against the\n * collection seen previously) and maps changes in the collection to views structure (by adding,\n * removing or moving views as needed).\n * @param metadataSlotIdx - index in data where we can find an instance of RepeaterMetadata with\n *     additional information (ex. differ) needed to process collection diffing and view\n *     manipulation\n * @param collection - the collection instance to be checked for changes\n * @codeGenApi\n */\nexport function ɵɵrepeater(\n    metadataSlotIdx: number, collection: Iterable<unknown>|undefined|null): void {\n  const prevConsumer = setActiveConsumer(null);\n  try {\n    const hostLView = getLView();\n    const hostTView = hostLView[TVIEW];\n    const metadata = hostLView[HEADER_OFFSET + metadataSlotIdx] as RepeaterMetadata;\n\n    if (metadata.liveCollection === undefined) {\n      const containerIndex = metadataSlotIdx + 1;\n      const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);\n      const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);\n      metadata.liveCollection =\n          new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);\n    } else {\n      metadata.liveCollection.reset();\n    }\n\n    const liveCollection = metadata.liveCollection;\n    reconcile(liveCollection, collection, metadata.trackByFn);\n\n    // moves in the container might caused context's index to get out of order, re-adjust if needed\n    liveCollection.updateIndexes();\n\n    // handle empty blocks\n    if (metadata.hasEmptyBlock) {\n      const bindingIndex = nextBindingIndex();\n      const isCollectionEmpty = liveCollection.length === 0;\n      if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {\n        const emptyTemplateIndex = metadataSlotIdx + 2;\n        const lContainerForEmpty = getLContainer(hostLView, HEADER_OFFSET + emptyTemplateIndex);\n        if (isCollectionEmpty) {\n          const emptyTemplateTNode = getExistingTNode(hostTView, emptyTemplateIndex);\n          const dehydratedView =\n              findMatchingDehydratedView(lContainerForEmpty, emptyTemplateTNode.tView!.ssrId);\n          const embeddedLView = createAndRenderEmbeddedLView(\n              hostLView, emptyTemplateTNode, undefined, {dehydratedView});\n          addLViewToLContainer(\n              lContainerForEmpty, embeddedLView, 0,\n              shouldAddViewToDom(emptyTemplateTNode, dehydratedView));\n        } else {\n          removeLViewFromLContainer(lContainerForEmpty, 0);\n        }\n      }\n    }\n  } finally {\n    setActiveConsumer(prevConsumer);\n  }\n}\n\nfunction getLContainer(lView: LView, index: number): LContainer {\n  const lContainer = lView[index];\n  ngDevMode && assertLContainer(lContainer);\n\n  return lContainer;\n}\n\nfunction detachExistingView<T>(lContainer: LContainer, index: number): LView<T> {\n  const existingLView = detachView(lContainer, index);\n  ngDevMode && assertLView(existingLView);\n\n  return existingLView as LView<T>;\n}\n\nfunction getExistingLViewFromLContainer<T>(lContainer: LContainer, index: number): LView<T> {\n  const existingLView = getLViewFromLContainer<T>(lContainer, index);\n  ngDevMode && assertLView(existingLView);\n\n  return existingLView!;\n}\n\nfunction getExistingTNode(tView: TView, index: number): TNode {\n  const tNode = getTNode(tView, index + HEADER_OFFSET);\n  ngDevMode && assertTNode(tNode);\n\n  return tNode;\n}\n"]}