@angular/core
Version:
Angular - the core framework
341 lines • 56.6 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 { NgModuleRef as viewEngine_NgModuleRef } from '../linker/ng_module_factory';
import { addToArray, removeFromArray } from '../util/array_utils';
import { assertDefined, assertEqual, assertGreaterThan, assertLessThan } from '../util/assert';
import { assertLContainer } from './assert';
import { getParentInjectorLocation, NodeInjector } from './di';
import { addToViewTree, createLContainer, createLView, renderView } from './instructions/shared';
import { CONTAINER_HEADER_OFFSET, VIEW_REFS } from './interfaces/container';
import { isProceduralRenderer } from './interfaces/renderer';
import { isComponentHost, isLContainer, isLView, isRootView } from './interfaces/type_checks';
import { DECLARATION_COMPONENT_VIEW, DECLARATION_LCONTAINER, PARENT, QUERIES, RENDERER, T_HOST, TVIEW } 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 { getComponentLViewByIndex, getNativeByTNode, unwrapRNode, viewAttachedToContainer } from './util/view_utils';
import { ViewRef } from './view_ref';
/**
* Creates an ElementRef from the most recent node.
*
* @returns The ElementRef instance to use
*/
export function injectElementRef(ElementRefToken) {
return createElementRef(ElementRefToken, getPreviousOrParentTNode(), getLView());
}
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
* @returns The ElementRef instance to use
*/
export function createElementRef(ElementRefToken, tNode, view) {
if (!R3ElementRef) {
R3ElementRef = class ElementRef extends ElementRefToken {
};
}
return new R3ElementRef(getNativeByTNode(tNode, view));
}
let R3TemplateRef;
/**
* Creates a TemplateRef given a node.
*
* @returns 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.
*
* @param TemplateRefToken The TemplateRef type
* @param ElementRefToken The ElementRef type
* @param hostTNode The node on which a TemplateRef is requested
* @param hostView The view to which the node belongs
* @returns The TemplateRef instance or null if we can't create a TemplateRef on a given node type
*/
export function createTemplateRef(TemplateRefToken, ElementRefToken, hostTNode, hostView) {
if (!R3TemplateRef) {
R3TemplateRef = class TemplateRef extends TemplateRefToken {
constructor(_declarationView, _declarationTContainer, elementRef) {
super();
this._declarationView = _declarationView;
this._declarationTContainer = _declarationTContainer;
this.elementRef = elementRef;
}
createEmbeddedView(context) {
const embeddedTView = this._declarationTContainer.tViews;
const embeddedLView = createLView(this._declarationView, embeddedTView, context, 16 /* CheckAlways */, null, embeddedTView.node);
const declarationLContainer = this._declarationView[this._declarationTContainer.index];
ngDevMode && assertLContainer(declarationLContainer);
embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
const declarationViewLQueries = this._declarationView[QUERIES];
if (declarationViewLQueries !== null) {
embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
}
renderView(embeddedTView, embeddedLView, context);
return new ViewRef(embeddedLView);
}
};
}
if (hostTNode.type === 0 /* Container */) {
ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');
return new R3TemplateRef(hostView, hostTNode, createElementRef(ElementRefToken, hostTNode, hostView));
}
else {
return null;
}
}
let R3ViewContainerRef;
/**
* Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef
* already exists, retrieves the existing ViewContainerRef.
*
* @returns The ViewContainerRef instance to use
*/
export function injectViewContainerRef(ViewContainerRefToken, ElementRefToken) {
const previousTNode = 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
* @returns The ViewContainerRef instance to use
*/
export function createContainerRef(ViewContainerRefToken, ElementRefToken, hostTNode, hostView) {
if (!R3ViewContainerRef) {
R3ViewContainerRef = class ViewContainerRef extends ViewContainerRefToken {
constructor(_lContainer, _hostTNode, _hostView) {
super();
this._lContainer = _lContainer;
this._hostTNode = _hostTNode;
this._hostView = _hostView;
}
get element() {
return createElementRef(ElementRefToken, this._hostTNode, this._hostView);
}
get injector() {
return new NodeInjector(this._hostTNode, this._hostView);
}
/** @deprecated No replacement */
get parentInjector() {
const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostView);
const parentView = getParentInjectorView(parentLocation, this._hostView);
const parentTNode = getParentInjectorTNode(parentLocation, this._hostView, this._hostTNode);
return !hasParentInjector(parentLocation) || parentTNode == null ?
new NodeInjector(null, this._hostView) :
new NodeInjector(parentTNode, parentView);
}
clear() {
while (this.length > 0) {
this.remove(this.length - 1);
}
}
get(index) {
return this._lContainer[VIEW_REFS] !== null && this._lContainer[VIEW_REFS][index] || null;
}
get length() {
return this._lContainer.length - CONTAINER_HEADER_OFFSET;
}
createEmbeddedView(templateRef, context, index) {
const viewRef = templateRef.createEmbeddedView(context || {});
this.insert(viewRef, index);
return viewRef;
}
createComponent(componentFactory, index, injector, projectableNodes, ngModuleRef) {
const contextInjector = injector || this.parentInjector;
if (!ngModuleRef && componentFactory.ngModule == null && contextInjector) {
// DO NOT REFACTOR. The code here used to have a `value || undefined` expression
// which seems to cause internal google apps to fail. This is documented in the
// following internal bug issue: go/b/142967802
const result = contextInjector.get(viewEngine_NgModuleRef, null);
if (result) {
ngModuleRef = result;
}
}
const componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);
this.insert(componentRef.hostView, index);
return componentRef;
}
insert(viewRef, index) {
const lView = viewRef._lView;
const tView = lView[TVIEW];
if (viewRef.destroyed) {
throw new Error('Cannot insert a destroyed View in a ViewContainer!');
}
this.allocateContainerIfNeeded();
if (viewAttachedToContainer(lView)) {
// If view is already attached, detach it first so we clean up references appropriately.
const prevIdx = this.indexOf(viewRef);
// A view might be attached either to this or a different container. The `prevIdx` for
// those cases will be:
// equal to -1 for views attached to this ViewContainerRef
// >= 0 for views attached to a different ViewContainerRef
if (prevIdx !== -1) {
this.detach(prevIdx);
}
else {
const prevLContainer = lView[PARENT];
ngDevMode &&
assertEqual(isLContainer(prevLContainer), true, 'An attached view should have its PARENT point to a container.');
// We need to re-create a R3ViewContainerRef instance since those are not stored on
// LView (nor anywhere else).
const prevVCRef = new R3ViewContainerRef(prevLContainer, prevLContainer[T_HOST], prevLContainer[PARENT]);
prevVCRef.detach(prevVCRef.indexOf(viewRef));
}
}
const adjustedIdx = this._adjustIndex(index);
insertView(tView, lView, this._lContainer, adjustedIdx);
const beforeNode = getBeforeNodeForView(adjustedIdx, this._lContainer);
addRemoveViewFromContainer(tView, lView, true, beforeNode);
viewRef.attachToViewContainerRef(this);
addToArray(this._lContainer[VIEW_REFS], adjustedIdx, viewRef);
return viewRef;
}
move(viewRef, newIndex) {
if (viewRef.destroyed) {
throw new Error('Cannot move a destroyed View in a ViewContainer!');
}
return this.insert(viewRef, newIndex);
}
indexOf(viewRef) {
const viewRefsArr = this._lContainer[VIEW_REFS];
return viewRefsArr !== null ? viewRefsArr.indexOf(viewRef) : -1;
}
remove(index) {
this.allocateContainerIfNeeded();
const adjustedIdx = this._adjustIndex(index, -1);
removeView(this._lContainer, adjustedIdx);
removeFromArray(this._lContainer[VIEW_REFS], adjustedIdx);
}
detach(index) {
this.allocateContainerIfNeeded();
const adjustedIdx = this._adjustIndex(index, -1);
const view = detachView(this._lContainer, adjustedIdx);
const wasDetached = view && removeFromArray(this._lContainer[VIEW_REFS], adjustedIdx) != null;
return wasDetached ? new ViewRef(view) : null;
}
_adjustIndex(index, shift = 0) {
if (index == null) {
return this.length + shift;
}
if (ngDevMode) {
assertGreaterThan(index, -1, `ViewRef index must be positive, got ${index}`);
// +1 because it's legal to insert at the end.
assertLessThan(index, this.length + 1 + shift, 'index');
}
return index;
}
allocateContainerIfNeeded() {
if (this._lContainer[VIEW_REFS] === null) {
this._lContainer[VIEW_REFS] = [];
}
}
};
}
ngDevMode &&
assertNodeOfPossibleTypes(hostTNode, [0 /* Container */, 3 /* Element */, 4 /* ElementContainer */]);
let lContainer;
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;
}
else {
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.
// The comment node in question is already part of the DOM structure so we don't need to append
// it again.
if (hostTNode.type === 4 /* ElementContainer */) {
commentNode = unwrapRNode(slotValue);
}
else {
ngDevMode && ngDevMode.rendererCreateComment++;
commentNode = hostView[RENDERER].createComment(ngDevMode ? 'container' : '');
// A `ViewContainerRef` can be injected by the root (topmost / bootstrapped) component. In
// this case we can't use TView / TNode data structures to insert container's marker node
// (both a parent of a comment node and the comment node itself are not part of any view). In
// this specific case we use low-level DOM manipulation to insert container's marker (comment)
// node.
if (isRootView(hostView)) {
const renderer = hostView[RENDERER];
const hostNative = getNativeByTNode(hostTNode, hostView);
const parentOfHostNative = nativeParentNode(renderer, hostNative);
nativeInsertBefore(renderer, parentOfHostNative, commentNode, nativeNextSibling(renderer, hostNative));
}
else {
appendChild(hostView[TVIEW], hostView, commentNode, hostTNode);
}
}
hostView[hostTNode.index] = lContainer =
createLContainer(slotValue, hostView, commentNode, hostTNode);
addToViewTree(hostView, lContainer);
}
return new R3ViewContainerRef(lContainer, hostTNode, hostView);
}
/** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */
export function injectChangeDetectorRef(isPipe = false) {
return createViewRef(getPreviousOrParentTNode(), getLView(), isPipe);
}
/**
* Creates a ViewRef and stores it on the injector as ChangeDetectorRef (public alias).
*
* @param tNode The node that is requesting a ChangeDetectorRef
* @param lView The view to which the node belongs
* @param isPipe Whether the view is being injected into a pipe.
* @returns The ChangeDetectorRef to use
*/
function createViewRef(tNode, lView, isPipe) {
// `isComponentView` will be true for Component and Directives (but not for Pipes).
// See https://github.com/angular/angular/pull/33072 for proper fix
const isComponentView = !isPipe && isComponentHost(tNode);
if (isComponentView) {
// The LView represents the location where the component is declared.
// Instead we want the LView for the component View and so we need to look it up.
const componentView = getComponentLViewByIndex(tNode.index, lView); // look down
return new ViewRef(componentView, componentView);
}
else if (tNode.type === 3 /* Element */ || tNode.type === 0 /* Container */ ||
tNode.type === 4 /* ElementContainer */ || tNode.type === 5 /* IcuContainer */) {
// The LView represents the location where the injection is requested from.
// We need to locate the containing LView (in case where the `lView` is an embedded view)
const hostComponentView = lView[DECLARATION_COMPONENT_VIEW]; // look up
return new ViewRef(hostComponentView, lView);
}
return null;
}
/** Returns a Renderer2 (or throws when application was bootstrapped with Renderer3) */
function getOrCreateRenderer2(view) {
const renderer = view[RENDERER];
if (isProceduralRenderer(renderer)) {
return renderer;
}
else {
throw new Error('Cannot inject Renderer2 when the application uses Renderer3!');
}
}
/** Injects a Renderer2 for the current component. */
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.
const lView = getLView();
const tNode = getPreviousOrParentTNode();
const nodeAtIndex = getComponentLViewByIndex(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 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 {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 {addToArray, removeFromArray} from '../util/array_utils';\nimport {assertDefined, assertEqual, assertGreaterThan, assertLessThan} from '../util/assert';\n\nimport {assertLContainer} from './assert';\nimport {getParentInjectorLocation, NodeInjector} from './di';\nimport {addToViewTree, createLContainer, createLView, renderView} from './instructions/shared';\nimport {CONTAINER_HEADER_OFFSET, LContainer, VIEW_REFS} from './interfaces/container';\nimport {TContainerNode, TDirectiveHostNode, TElementContainerNode, TElementNode, TNode, TNodeType, TViewNode} from './interfaces/node';\nimport {isProceduralRenderer, RComment, RElement} from './interfaces/renderer';\nimport {isComponentHost, isLContainer, isLView, isRootView} from './interfaces/type_checks';\nimport {DECLARATION_COMPONENT_VIEW, DECLARATION_LCONTAINER, LView, LViewFlags, PARENT, QUERIES, RENDERER, T_HOST, TVIEW, TView} 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 {getComponentLViewByIndex, getNativeByTNode, 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    R3ElementRef = class ElementRef extends ElementRefToken {};\n  }\n  return new R3ElementRef(getNativeByTNode(tNode, view) as RElement);\n}\n\nlet R3TemplateRef: {\n  new (_declarationParentView: LView, hostTNode: TContainerNode, elementRef: ViewEngine_ElementRef):\n      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 on which a TemplateRef is requested\n * @param hostView The view to which the node belongs\n * @returns The TemplateRef instance or null if we can't create a TemplateRef on a given node type\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    R3TemplateRef = class TemplateRef<T> extends TemplateRefToken<T>{\n      constructor(\n          private _declarationView: LView, private _declarationTContainer: TContainerNode,\n          readonly elementRef: ViewEngine_ElementRef) {\n        super();\n      }\n\n      createEmbeddedView(context: T): viewEngine_EmbeddedViewRef<T> {\n        const embeddedTView = this._declarationTContainer.tViews as TView;\n        const embeddedLView = createLView(\n            this._declarationView, embeddedTView, context, LViewFlags.CheckAlways, null,\n            embeddedTView.node);\n\n        const declarationLContainer = this._declarationView[this._declarationTContainer.index];\n        ngDevMode && assertLContainer(declarationLContainer);\n        embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;\n\n        const declarationViewLQueries = this._declarationView[QUERIES];\n        if (declarationViewLQueries !== null) {\n          embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);\n        }\n\n        renderView(embeddedTView, embeddedLView, context);\n\n        return new ViewRef<T>(embeddedLView);\n      }\n    };\n  }\n\n  if (hostTNode.type === TNodeType.Container) {\n    ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');\n    return new R3TemplateRef(\n        hostView, hostTNode as TContainerNode,\n        createElementRef(ElementRefToken, hostTNode, hostView));\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    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 {\n        return new NodeInjector(this._hostTNode, this._hostView);\n      }\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 > 0) {\n          this.remove(this.length - 1);\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        return this._lContainer.length - CONTAINER_HEADER_OFFSET;\n      }\n\n      createEmbeddedView<C>(templateRef: ViewEngine_TemplateRef<C>, context?: C, index?: number):\n          viewEngine_EmbeddedViewRef<C> {\n        const viewRef = templateRef.createEmbeddedView(context || <any>{});\n        this.insert(viewRef, index);\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          // DO NOT REFACTOR. The code here used to have a `value || undefined` expression\n          // which seems to cause internal google apps to fail. This is documented in the\n          // following internal bug issue: go/b/142967802\n          const result = contextInjector.get(viewEngine_NgModuleRef, null);\n          if (result) {\n            ngModuleRef = result;\n          }\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        const lView = (viewRef as ViewRef<any>)._lView!;\n        const tView = lView[TVIEW];\n\n        if (viewRef.destroyed) {\n          throw new Error('Cannot insert a destroyed View in a ViewContainer!');\n        }\n\n        this.allocateContainerIfNeeded();\n\n        if (viewAttachedToContainer(lView)) {\n          // If view is already attached, detach it first so we clean up references appropriately.\n\n          const prevIdx = this.indexOf(viewRef);\n\n          // A view might be attached either to this or a different container. The `prevIdx` for\n          // those cases will be:\n          // equal to -1 for views attached to this ViewContainerRef\n          // >= 0 for views attached to a different ViewContainerRef\n          if (prevIdx !== -1) {\n            this.detach(prevIdx);\n          } else {\n            const prevLContainer = lView[PARENT] as LContainer;\n            ngDevMode &&\n                assertEqual(\n                    isLContainer(prevLContainer), true,\n                    'An attached view should have its PARENT point to a container.');\n\n\n            // We need to re-create a R3ViewContainerRef instance since those are not stored on\n            // LView (nor anywhere else).\n            const prevVCRef = new R3ViewContainerRef(\n                prevLContainer, prevLContainer[T_HOST] as TDirectiveHostNode,\n                prevLContainer[PARENT]);\n\n            prevVCRef.detach(prevVCRef.indexOf(viewRef));\n          }\n        }\n\n        const adjustedIdx = this._adjustIndex(index);\n        insertView(tView, lView, this._lContainer, adjustedIdx);\n\n        const beforeNode = getBeforeNodeForView(adjustedIdx, this._lContainer);\n        addRemoveViewFromContainer(tView, lView, true, beforeNode);\n\n        (viewRef as ViewRef<any>).attachToViewContainerRef(this);\n        addToArray(this._lContainer[VIEW_REFS]!, adjustedIdx, viewRef);\n\n        return viewRef;\n      }\n\n      move(viewRef: viewEngine_ViewRef, newIndex: number): viewEngine_ViewRef {\n        if (viewRef.destroyed) {\n          throw new Error('Cannot move a destroyed View in a ViewContainer!');\n        }\n        return this.insert(viewRef, newIndex);\n      }\n\n      indexOf(viewRef: viewEngine_ViewRef): number {\n        const viewRefsArr = this._lContainer[VIEW_REFS];\n        return viewRefsArr !== null ? viewRefsArr.indexOf(viewRef) : -1;\n      }\n\n      remove(index?: number): void {\n        this.allocateContainerIfNeeded();\n        const adjustedIdx = this._adjustIndex(index, -1);\n        removeView(this._lContainer, adjustedIdx);\n        removeFromArray(this._lContainer[VIEW_REFS]!, adjustedIdx);\n      }\n\n      detach(index?: number): viewEngine_ViewRef|null {\n        this.allocateContainerIfNeeded();\n        const adjustedIdx = this._adjustIndex(index, -1);\n        const view = detachView(this._lContainer, adjustedIdx);\n\n        const wasDetached =\n            view && removeFromArray(this._lContainer[VIEW_REFS]!, adjustedIdx) != null;\n        return wasDetached ? new ViewRef(view!) : null;\n      }\n\n      private _adjustIndex(index?: number, shift: number = 0) {\n        if (index == null) {\n          return this.length + shift;\n        }\n        if (ngDevMode) {\n          assertGreaterThan(index, -1, `ViewRef index must be positive, got ${index}`);\n          // +1 because it's legal to insert at the end.\n          assertLessThan(index, this.length + 1 + shift, 'index