@angular/core
Version:
Angular - the core framework
470 lines • 57.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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 { NgModuleRef as viewEngine_NgModuleRef } from '../linker/ng_module_factory';
import { assertDefined, assertGreaterThan, assertLessThan } from '../util/assert';
import { NodeInjector, getParentInjectorLocation } from './di';
import { addToViewTree, createEmbeddedViewAndNode, createLContainer, renderEmbeddedTemplate } from './instructions/shared';
import { ACTIVE_INDEX, CONTAINER_HEADER_OFFSET, VIEW_REFS } from './interfaces/container';
import { isProceduralRenderer } from './interfaces/renderer';
import { CONTEXT, QUERIES, RENDERER, T_HOST } from './interfaces/view';
import { assertNodeOfPossibleTypes } from './node_assert';
import { addRemoveViewFromContainer, appendChild, detachView, getBeforeNodeForView, insertView, nativeInsertBefore, nativeNextSibling, nativeParentNode, removeView } from './node_manipulation';
import { getParentInjectorTNode } from './node_util';
import { getLView, getPreviousOrParentTNode } from './state';
import { getParentInjectorView, hasParentInjector } from './util/injector_utils';
import { findComponentView } from './util/view_traversal_utils';
import { getComponentViewByIndex, getNativeByTNode, isComponent, isLContainer, isLView, isRootView, unwrapRNode, viewAttachedToContainer } from './util/view_utils';
import { ViewRef } from './view_ref';
/**
* Creates an ElementRef from the most recent node.
*
* @param {?} ElementRefToken
* @return {?} The ElementRef instance to use
*/
export function injectElementRef(ElementRefToken) {
return createElementRef(ElementRefToken, getPreviousOrParentTNode(), getLView());
}
/** @type {?} */
let R3ElementRef;
/**
* Creates an ElementRef given a node.
*
* @param {?} ElementRefToken The ElementRef type
* @param {?} tNode The node for which you'd like an ElementRef
* @param {?} view The view to which the node belongs
* @return {?} The ElementRef instance to use
*/
export function createElementRef(ElementRefToken, tNode, view) {
if (!R3ElementRef) {
// TODO: Fix class name, should be ElementRef, but there appears to be a rollup bug
R3ElementRef = class ElementRef_ extends ElementRefToken {
};
}
return new R3ElementRef((/** @type {?} */ (getNativeByTNode(tNode, view))));
}
/** @type {?} */
let R3TemplateRef;
/**
* Creates a TemplateRef given a node.
*
* @template T
* @param {?} TemplateRefToken
* @param {?} ElementRefToken
* @return {?} The TemplateRef instance to use
*/
export function injectTemplateRef(TemplateRefToken, ElementRefToken) {
return createTemplateRef(TemplateRefToken, ElementRefToken, getPreviousOrParentTNode(), getLView());
}
/**
* Creates a TemplateRef and stores it on the injector.
*
* @template T
* @param {?} TemplateRefToken The TemplateRef type
* @param {?} ElementRefToken The ElementRef type
* @param {?} hostTNode The node that is requesting a TemplateRef
* @param {?} hostView The view to which the node belongs
* @return {?} The TemplateRef instance to use
*/
export function createTemplateRef(TemplateRefToken, ElementRefToken, hostTNode, hostView) {
if (!R3TemplateRef) {
// TODO: Fix class name, should be TemplateRef, but there appears to be a rollup bug
R3TemplateRef = class TemplateRef_ extends TemplateRefToken {
/**
* @param {?} _declarationParentView
* @param {?} elementRef
* @param {?} _tView
* @param {?} _hostLContainer
* @param {?} _injectorIndex
*/
constructor(_declarationParentView, elementRef, _tView, _hostLContainer, _injectorIndex) {
super();
this._declarationParentView = _declarationParentView;
this.elementRef = elementRef;
this._tView = _tView;
this._hostLContainer = _hostLContainer;
this._injectorIndex = _injectorIndex;
}
/**
* @param {?} context
* @param {?=} container
* @param {?=} index
* @return {?}
*/
createEmbeddedView(context, container, index) {
/** @type {?} */
const currentQueries = this._declarationParentView[QUERIES];
// Query container may be missing if this view was created in a directive
// constructor. Create it now to avoid losing results in embedded views.
if (currentQueries && this._hostLContainer[QUERIES] == null) {
this._hostLContainer[QUERIES] = (/** @type {?} */ (currentQueries)).container();
}
/** @type {?} */
const lView = createEmbeddedViewAndNode(this._tView, context, this._declarationParentView, this._hostLContainer[QUERIES], this._injectorIndex);
if (container) {
insertView(lView, container, (/** @type {?} */ (index)));
}
renderEmbeddedTemplate(lView, this._tView, context);
/** @type {?} */
const viewRef = new ViewRef(lView, context, -1);
viewRef._tViewNode = (/** @type {?} */ (lView[T_HOST]));
return viewRef;
}
};
}
if (hostTNode.type === 0 /* Container */) {
/** @type {?} */
const hostContainer = hostView[hostTNode.index];
ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');
return new R3TemplateRef(hostView, createElementRef(ElementRefToken, hostTNode, hostView), (/** @type {?} */ (hostTNode.tViews)), hostContainer, hostTNode.injectorIndex);
}
else {
return null;
}
}
/** @type {?} */
let R3ViewContainerRef;
/**
* Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef
* already exists, retrieves the existing ViewContainerRef.
*
* @param {?} ViewContainerRefToken
* @param {?} ElementRefToken
* @return {?} The ViewContainerRef instance to use
*/
export function injectViewContainerRef(ViewContainerRefToken, ElementRefToken) {
/** @type {?} */
const previousTNode = (/** @type {?} */ (getPreviousOrParentTNode()));
return createContainerRef(ViewContainerRefToken, ElementRefToken, previousTNode, getLView());
}
/**
* Creates a ViewContainerRef and stores it on the injector.
*
* @param {?} ViewContainerRefToken The ViewContainerRef type
* @param {?} ElementRefToken The ElementRef type
* @param {?} hostTNode The node that is requesting a ViewContainerRef
* @param {?} hostView The view to which the node belongs
* @return {?} The ViewContainerRef instance to use
*/
export function createContainerRef(ViewContainerRefToken, ElementRefToken, hostTNode, hostView) {
if (!R3ViewContainerRef) {
// TODO: Fix class name, should be ViewContainerRef, but there appears to be a rollup bug
R3ViewContainerRef = class ViewContainerRef_ extends ViewContainerRefToken {
/**
* @param {?} _lContainer
* @param {?} _hostTNode
* @param {?} _hostView
*/
constructor(_lContainer, _hostTNode, _hostView) {
super();
this._lContainer = _lContainer;
this._hostTNode = _hostTNode;
this._hostView = _hostView;
}
/**
* @return {?}
*/
get element() {
return createElementRef(ElementRefToken, this._hostTNode, this._hostView);
}
/**
* @return {?}
*/
get injector() { return new NodeInjector(this._hostTNode, this._hostView); }
/**
* @deprecated No replacement
* @return {?}
*/
get parentInjector() {
/** @type {?} */
const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostView);
/** @type {?} */
const parentView = getParentInjectorView(parentLocation, this._hostView);
/** @type {?} */
const parentTNode = getParentInjectorTNode(parentLocation, this._hostView, this._hostTNode);
return !hasParentInjector(parentLocation) || parentTNode == null ?
new NodeInjector(null, this._hostView) :
new NodeInjector(parentTNode, parentView);
}
/**
* @return {?}
*/
clear() {
while (this.length) {
this.remove(0);
}
}
/**
* @param {?} index
* @return {?}
*/
get(index) {
return this._lContainer[VIEW_REFS] !== null && (/** @type {?} */ (this._lContainer[VIEW_REFS]))[index] || null;
}
/**
* @return {?}
*/
get length() {
// Note that if there are no views, the container
// length will be smaller than the header offset.
/** @type {?} */
const viewAmount = this._lContainer.length - CONTAINER_HEADER_OFFSET;
return viewAmount > 0 ? viewAmount : 0;
}
/**
* @template C
* @param {?} templateRef
* @param {?=} context
* @param {?=} index
* @return {?}
*/
createEmbeddedView(templateRef, context, index) {
this.allocateContainerIfNeeded();
/** @type {?} */
const adjustedIdx = this._adjustIndex(index);
/** @type {?} */
const viewRef = ((/** @type {?} */ (templateRef)))
.createEmbeddedView(context || (/** @type {?} */ ({})), this._lContainer, adjustedIdx);
((/** @type {?} */ (viewRef))).attachToViewContainerRef(this);
(/** @type {?} */ (this._lContainer[VIEW_REFS])).splice(adjustedIdx, 0, viewRef);
return viewRef;
}
/**
* @template C
* @param {?} componentFactory
* @param {?=} index
* @param {?=} injector
* @param {?=} projectableNodes
* @param {?=} ngModuleRef
* @return {?}
*/
createComponent(componentFactory, index, injector, projectableNodes, ngModuleRef) {
/** @type {?} */
const contextInjector = injector || this.parentInjector;
if (!ngModuleRef && ((/** @type {?} */ (componentFactory))).ngModule == null && contextInjector) {
ngModuleRef = contextInjector.get(viewEngine_NgModuleRef, null);
}
/** @type {?} */
const componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);
this.insert(componentRef.hostView, index);
return componentRef;
}
/**
* @param {?} viewRef
* @param {?=} index
* @return {?}
*/
insert(viewRef, index) {
if (viewRef.destroyed) {
throw new Error('Cannot insert a destroyed View in a ViewContainer!');
}
this.allocateContainerIfNeeded();
/** @type {?} */
const lView = (/** @type {?} */ (((/** @type {?} */ (viewRef)))._lView));
/** @type {?} */
const adjustedIdx = this._adjustIndex(index);
if (viewAttachedToContainer(lView)) {
// If view is already attached, fall back to move() so we clean up
// references appropriately.
return this.move(viewRef, adjustedIdx);
}
insertView(lView, this._lContainer, adjustedIdx);
/** @type {?} */
const beforeNode = getBeforeNodeForView(adjustedIdx, this._lContainer);
addRemoveViewFromContainer(lView, true, beforeNode);
((/** @type {?} */ (viewRef))).attachToViewContainerRef(this);
(/** @type {?} */ (this._lContainer[VIEW_REFS])).splice(adjustedIdx, 0, viewRef);
return viewRef;
}
/**
* @param {?} viewRef
* @param {?} newIndex
* @return {?}
*/
move(viewRef, newIndex) {
if (viewRef.destroyed) {
throw new Error('Cannot move a destroyed View in a ViewContainer!');
}
/** @type {?} */
const index = this.indexOf(viewRef);
if (index !== -1)
this.detach(index);
this.insert(viewRef, newIndex);
return viewRef;
}
/**
* @param {?} viewRef
* @return {?}
*/
indexOf(viewRef) {
return this._lContainer[VIEW_REFS] !== null ?
(/** @type {?} */ (this._lContainer[VIEW_REFS])).indexOf(viewRef) :
0;
}
/**
* @param {?=} index
* @return {?}
*/
remove(index) {
this.allocateContainerIfNeeded();
/** @type {?} */
const adjustedIdx = this._adjustIndex(index, -1);
removeView(this._lContainer, adjustedIdx);
(/** @type {?} */ (this._lContainer[VIEW_REFS])).splice(adjustedIdx, 1);
}
/**
* @param {?=} index
* @return {?}
*/
detach(index) {
this.allocateContainerIfNeeded();
/** @type {?} */
const adjustedIdx = this._adjustIndex(index, -1);
/** @type {?} */
const view = detachView(this._lContainer, adjustedIdx);
/** @type {?} */
const wasDetached = view && (/** @type {?} */ (this._lContainer[VIEW_REFS])).splice(adjustedIdx, 1)[0] != null;
return wasDetached ? new ViewRef((/** @type {?} */ (view)), (/** @type {?} */ (view))[CONTEXT], -1) : null;
}
/**
* @private
* @param {?=} index
* @param {?=} shift
* @return {?}
*/
_adjustIndex(index, shift = 0) {
if (index == null) {
return this.length + shift;
}
if (ngDevMode) {
assertGreaterThan(index, -1, 'index must be positive');
// +1 because it's legal to insert at the end.
assertLessThan(index, this.length + 1 + shift, 'index');
}
return index;
}
/**
* @private
* @return {?}
*/
allocateContainerIfNeeded() {
if (this._lContainer[VIEW_REFS] === null) {
this._lContainer[VIEW_REFS] = [];
}
}
};
}
ngDevMode && assertNodeOfPossibleTypes(hostTNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */);
/** @type {?} */
let lContainer;
/** @type {?} */
const slotValue = hostView[hostTNode.index];
if (isLContainer(slotValue)) {
// If the host is a container, we don't need to create a new LContainer
lContainer = slotValue;
lContainer[ACTIVE_INDEX] = -1;
}
else {
/** @type {?} */
let commentNode;
// If the host is an element container, the native host element is guaranteed to be a
// comment and we can reuse that comment as anchor element for the new LContainer.
if (hostTNode.type === 4 /* ElementContainer */) {
commentNode = (/** @type {?} */ (unwrapRNode(slotValue)));
}
else {
ngDevMode && ngDevMode.rendererCreateComment++;
commentNode = hostView[RENDERER].createComment(ngDevMode ? 'container' : '');
}
// A container can be created on the root (topmost / bootstrapped) component and in this case we
// can't use LTree to insert container's marker node (both parent of a comment node and the
// commend node itself is located outside of elements hold by LTree). In this specific case we
// use low-level DOM manipulation to insert container's marker (comment) node.
if (isRootView(hostView)) {
/** @type {?} */
const renderer = hostView[RENDERER];
/** @type {?} */
const hostNative = (/** @type {?} */ (getNativeByTNode(hostTNode, hostView)));
/** @type {?} */
const parentOfHostNative = nativeParentNode(renderer, hostNative);
nativeInsertBefore(renderer, (/** @type {?} */ (parentOfHostNative)), commentNode, nativeNextSibling(renderer, hostNative));
}
else {
appendChild(commentNode, hostTNode, hostView);
}
hostView[hostTNode.index] = lContainer =
createLContainer(slotValue, hostView, commentNode, hostTNode, true);
addToViewTree(hostView, lContainer);
}
return new R3ViewContainerRef(lContainer, hostTNode, hostView);
}
/**
* Returns a ChangeDetectorRef (a.k.a. a ViewRef)
* @return {?}
*/
export function injectChangeDetectorRef() {
return createViewRef(getPreviousOrParentTNode(), getLView(), null);
}
/**
* Creates a ViewRef and stores it on the injector as ChangeDetectorRef (public alias).
*
* @param {?} hostTNode The node that is requesting a ChangeDetectorRef
* @param {?} hostView The view to which the node belongs
* @param {?} context The context for this change detector ref
* @return {?} The ChangeDetectorRef to use
*/
export function createViewRef(hostTNode, hostView, context) {
if (isComponent(hostTNode)) {
/** @type {?} */
const componentIndex = hostTNode.directiveStart;
/** @type {?} */
const componentView = getComponentViewByIndex(hostTNode.index, hostView);
return new ViewRef(componentView, context, componentIndex);
}
else if (hostTNode.type === 3 /* Element */ || hostTNode.type === 0 /* Container */ ||
hostTNode.type === 4 /* ElementContainer */) {
/** @type {?} */
const hostComponentView = findComponentView(hostView);
return new ViewRef(hostComponentView, hostComponentView[CONTEXT], -1);
}
return (/** @type {?} */ (null));
}
/**
* Returns a Renderer2 (or throws when application was bootstrapped with Renderer3)
* @param {?} view
* @return {?}
*/
function getOrCreateRenderer2(view) {
/** @type {?} */
const renderer = view[RENDERER];
if (isProceduralRenderer(renderer)) {
return (/** @type {?} */ (renderer));
}
else {
throw new Error('Cannot inject Renderer2 when the application uses Renderer3!');
}
}
/**
* Injects a Renderer2 for the current component.
* @return {?}
*/
export function injectRenderer2() {
// We need the Renderer to be based on the component that it's being injected into, however since
// DI happens before we've entered its view, `getLView` will return the parent view instead.
/** @type {?} */
const lView = getLView();
/** @type {?} */
const tNode = getPreviousOrParentTNode();
/** @type {?} */
const nodeAtIndex = getComponentViewByIndex(tNode.index, lView);
return getOrCreateRenderer2(isLView(nodeAtIndex) ? nodeAtIndex : lView);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_engine_compatibility.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/view_engine_compatibility.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {ChangeDetectorRef as ViewEngine_ChangeDetectorRef} from '../change_detection/change_detector_ref';\nimport {Injector} from '../di/injector';\nimport {ComponentFactory as viewEngine_ComponentFactory, ComponentRef as viewEngine_ComponentRef} from '../linker/component_factory';\nimport {ElementRef as ViewEngine_ElementRef} from '../linker/element_ref';\nimport {NgModuleRef as viewEngine_NgModuleRef} from '../linker/ng_module_factory';\nimport {TemplateRef as ViewEngine_TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef as ViewEngine_ViewContainerRef} from '../linker/view_container_ref';\nimport {EmbeddedViewRef as viewEngine_EmbeddedViewRef, ViewRef as viewEngine_ViewRef} from '../linker/view_ref';\nimport {Renderer2} from '../render/api';\nimport {assertDefined, assertGreaterThan, assertLessThan} from '../util/assert';\n\nimport {NodeInjector, getParentInjectorLocation} from './di';\nimport {addToViewTree, createEmbeddedViewAndNode, createLContainer, renderEmbeddedTemplate} from './instructions/shared';\nimport {ACTIVE_INDEX, CONTAINER_HEADER_OFFSET, LContainer, VIEW_REFS} from './interfaces/container';\nimport {TContainerNode, TElementContainerNode, TElementNode, TNode, TNodeType, TViewNode} from './interfaces/node';\nimport {RComment, RElement, isProceduralRenderer} from './interfaces/renderer';\nimport {CONTEXT, LView, QUERIES, RENDERER, TView, T_HOST} from './interfaces/view';\nimport {assertNodeOfPossibleTypes} from './node_assert';\nimport {addRemoveViewFromContainer, appendChild, detachView, getBeforeNodeForView, insertView, nativeInsertBefore, nativeNextSibling, nativeParentNode, removeView} from './node_manipulation';\nimport {getParentInjectorTNode} from './node_util';\nimport {getLView, getPreviousOrParentTNode} from './state';\nimport {getParentInjectorView, hasParentInjector} from './util/injector_utils';\nimport {findComponentView} from './util/view_traversal_utils';\nimport {getComponentViewByIndex, getNativeByTNode, isComponent, isLContainer, isLView, isRootView, unwrapRNode, viewAttachedToContainer} from './util/view_utils';\nimport {ViewRef} from './view_ref';\n\n\n\n/**\n * Creates an ElementRef from the most recent node.\n *\n * @returns The ElementRef instance to use\n */\nexport function injectElementRef(ElementRefToken: typeof ViewEngine_ElementRef):\n    ViewEngine_ElementRef {\n  return createElementRef(ElementRefToken, getPreviousOrParentTNode(), getLView());\n}\n\nlet R3ElementRef: {new (native: RElement | RComment): ViewEngine_ElementRef};\n\n/**\n * Creates an ElementRef given a node.\n *\n * @param ElementRefToken The ElementRef type\n * @param tNode The node for which you'd like an ElementRef\n * @param view The view to which the node belongs\n * @returns The ElementRef instance to use\n */\nexport function createElementRef(\n    ElementRefToken: typeof ViewEngine_ElementRef, tNode: TNode,\n    view: LView): ViewEngine_ElementRef {\n  if (!R3ElementRef) {\n    // TODO: Fix class name, should be ElementRef, but there appears to be a rollup bug\n    R3ElementRef = class ElementRef_ extends ElementRefToken {};\n  }\n  return new R3ElementRef(getNativeByTNode(tNode, view) as RElement);\n}\n\nlet R3TemplateRef: {\n  new (\n      _declarationParentView: LView, elementRef: ViewEngine_ElementRef, _tView: TView,\n      _hostLContainer: LContainer, _injectorIndex: number): ViewEngine_TemplateRef<any>\n};\n\n/**\n * Creates a TemplateRef given a node.\n *\n * @returns The TemplateRef instance to use\n */\nexport function injectTemplateRef<T>(\n    TemplateRefToken: typeof ViewEngine_TemplateRef,\n    ElementRefToken: typeof ViewEngine_ElementRef): ViewEngine_TemplateRef<T>|null {\n  return createTemplateRef<T>(\n      TemplateRefToken, ElementRefToken, getPreviousOrParentTNode(), getLView());\n}\n\n/**\n * Creates a TemplateRef and stores it on the injector.\n *\n * @param TemplateRefToken The TemplateRef type\n * @param ElementRefToken The ElementRef type\n * @param hostTNode The node that is requesting a TemplateRef\n * @param hostView The view to which the node belongs\n * @returns The TemplateRef instance to use\n */\nexport function createTemplateRef<T>(\n    TemplateRefToken: typeof ViewEngine_TemplateRef, ElementRefToken: typeof ViewEngine_ElementRef,\n    hostTNode: TNode, hostView: LView): ViewEngine_TemplateRef<T>|null {\n  if (!R3TemplateRef) {\n    // TODO: Fix class name, should be TemplateRef, but there appears to be a rollup bug\n    R3TemplateRef = class TemplateRef_<T> extends TemplateRefToken<T> {\n      constructor(\n          private _declarationParentView: LView, readonly elementRef: ViewEngine_ElementRef,\n          private _tView: TView, private _hostLContainer: LContainer,\n          private _injectorIndex: number) {\n        super();\n      }\n\n      createEmbeddedView(context: T, container?: LContainer, index?: number):\n          viewEngine_EmbeddedViewRef<T> {\n        const currentQueries = this._declarationParentView[QUERIES];\n        // Query container may be missing if this view was created in a directive\n        // constructor. Create it now to avoid losing results in embedded views.\n        if (currentQueries && this._hostLContainer[QUERIES] == null) {\n          this._hostLContainer[QUERIES] = currentQueries !.container();\n        }\n        const lView = createEmbeddedViewAndNode(\n            this._tView, context, this._declarationParentView, this._hostLContainer[QUERIES],\n            this._injectorIndex);\n        if (container) {\n          insertView(lView, container, index !);\n        }\n        renderEmbeddedTemplate(lView, this._tView, context);\n        const viewRef = new ViewRef(lView, context, -1);\n        viewRef._tViewNode = lView[T_HOST] as TViewNode;\n        return viewRef;\n      }\n    };\n  }\n\n  if (hostTNode.type === TNodeType.Container) {\n    const hostContainer: LContainer = hostView[hostTNode.index];\n    ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');\n    return new R3TemplateRef(\n        hostView, createElementRef(ElementRefToken, hostTNode, hostView), hostTNode.tViews as TView,\n        hostContainer, hostTNode.injectorIndex);\n  } else {\n    return null;\n  }\n}\n\nlet R3ViewContainerRef: {\n  new (\n      lContainer: LContainer, hostTNode: TElementNode | TContainerNode | TElementContainerNode,\n      hostView: LView): ViewEngine_ViewContainerRef\n};\n\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nexport function injectViewContainerRef(\n    ViewContainerRefToken: typeof ViewEngine_ViewContainerRef,\n    ElementRefToken: typeof ViewEngine_ElementRef): ViewEngine_ViewContainerRef {\n  const previousTNode =\n      getPreviousOrParentTNode() as TElementNode | TElementContainerNode | TContainerNode;\n  return createContainerRef(ViewContainerRefToken, ElementRefToken, previousTNode, getLView());\n}\n\n/**\n * Creates a ViewContainerRef and stores it on the injector.\n *\n * @param ViewContainerRefToken The ViewContainerRef type\n * @param ElementRefToken The ElementRef type\n * @param hostTNode The node that is requesting a ViewContainerRef\n * @param hostView The view to which the node belongs\n * @returns The ViewContainerRef instance to use\n */\nexport function createContainerRef(\n    ViewContainerRefToken: typeof ViewEngine_ViewContainerRef,\n    ElementRefToken: typeof ViewEngine_ElementRef,\n    hostTNode: TElementNode|TContainerNode|TElementContainerNode,\n    hostView: LView): ViewEngine_ViewContainerRef {\n  if (!R3ViewContainerRef) {\n    // TODO: Fix class name, should be ViewContainerRef, but there appears to be a rollup bug\n    R3ViewContainerRef = class ViewContainerRef_ extends ViewContainerRefToken {\n      constructor(\n          private _lContainer: LContainer,\n          private _hostTNode: TElementNode|TContainerNode|TElementContainerNode,\n          private _hostView: LView) {\n        super();\n      }\n\n      get element(): ViewEngine_ElementRef {\n        return createElementRef(ElementRefToken, this._hostTNode, this._hostView);\n      }\n\n      get injector(): Injector { return new NodeInjector(this._hostTNode, this._hostView); }\n\n      /** @deprecated No replacement */\n      get parentInjector(): Injector {\n        const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostView);\n        const parentView = getParentInjectorView(parentLocation, this._hostView);\n        const parentTNode = getParentInjectorTNode(parentLocation, this._hostView, this._hostTNode);\n\n        return !hasParentInjector(parentLocation) || parentTNode == null ?\n            new NodeInjector(null, this._hostView) :\n            new NodeInjector(parentTNode, parentView);\n      }\n\n      clear(): void {\n        while (this.length) {\n          this.remove(0);\n        }\n      }\n\n      get(index: number): viewEngine_ViewRef|null {\n        return this._lContainer[VIEW_REFS] !== null && this._lContainer[VIEW_REFS] ![index] || null;\n      }\n\n      get length(): number {\n        // Note that if there are no views, the container\n        // length will be smaller than the header offset.\n        const viewAmount = this._lContainer.length - CONTAINER_HEADER_OFFSET;\n        return viewAmount > 0 ? viewAmount : 0;\n      }\n\n      createEmbeddedView<C>(templateRef: ViewEngine_TemplateRef<C>, context?: C, index?: number):\n          viewEngine_EmbeddedViewRef<C> {\n        this.allocateContainerIfNeeded();\n        const adjustedIdx = this._adjustIndex(index);\n        const viewRef = (templateRef as any)\n                            .createEmbeddedView(context || <any>{}, this._lContainer, adjustedIdx);\n        (viewRef as ViewRef<any>).attachToViewContainerRef(this);\n        this._lContainer[VIEW_REFS] !.splice(adjustedIdx, 0, viewRef);\n        return viewRef;\n      }\n\n      createComponent<C>(\n          componentFactory: viewEngine_ComponentFactory<C>, index?: number|undefined,\n          injector?: Injector|undefined, projectableNodes?: any[][]|undefined,\n          ngModuleRef?: viewEngine_NgModuleRef<any>|undefined): viewEngine_ComponentRef<C> {\n        const contextInjector = injector || this.parentInjector;\n        if (!ngModuleRef && (componentFactory as any).ngModule == null && contextInjector) {\n          ngModuleRef = contextInjector.get(viewEngine_NgModuleRef, null);\n        }\n\n        const componentRef =\n            componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);\n        this.insert(componentRef.hostView, index);\n        return componentRef;\n      }\n\n      insert(viewRef: viewEngine_ViewRef, index?: number): viewEngine_ViewRef {\n        if (viewRef.destroyed) {\n          throw new Error('Cannot insert a destroyed View in a ViewContainer!');\n        }\n        this.allocateContainerIfNeeded();\n        const lView = (viewRef as ViewRef<any>)._lView !;\n        const adjustedIdx = this._adjustIndex(index);\n\n        if (viewAttachedToContainer(lView)) {\n          // If view is already attached, fall back to move() so we clean up\n          // references appropriately.\n          return this.move(viewRef, adjustedIdx);\n        }\n\n        insertView(lView, this._lContainer, adjustedIdx);\n\n        const beforeNode = getBeforeNodeForView(adjustedIdx, this._lContainer);\n        addRemoveViewFromContainer(lView, true, beforeNode);\n\n        (viewRef as ViewRef<any>).attachToViewContainerRef(this);\n        this._lContainer[VIEW_REFS] !.splice(adjustedIdx, 0, viewRef);\n\n        return viewRef