@angular/core
Version:
Angular - the core framework
384 lines • 42.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: packages/core/src/render3/component_ref.ts
* @suppress {checkTypes,constantProperty,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 { InjectionToken } from '../di/injection_token';
import { ComponentFactory as viewEngine_ComponentFactory, ComponentRef as viewEngine_ComponentRef } from '../linker/component_factory';
import { ComponentFactoryResolver as viewEngine_ComponentFactoryResolver } from '../linker/component_factory_resolver';
import { ElementRef as viewEngine_ElementRef } from '../linker/element_ref';
import { RendererFactory2 } from '../render/api';
import { Sanitizer } from '../sanitization/sanitizer';
import { VERSION } from '../version';
import { NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR } from '../view/provider';
import { assertComponentType } from './assert';
import { createRootComponent, createRootComponentView, createRootContext, LifecycleHooksFeature } from './component';
import { getComponentDef } from './definition';
import { NodeInjector } from './di';
import { assignTViewNodeToLView, createLView, createTView, elementCreate, locateHostElement, renderView } from './instructions/shared';
import { domRendererFactory3 } from './interfaces/renderer';
import { TVIEW } from './interfaces/view';
import { MATH_ML_NAMESPACE, SVG_NAMESPACE } from './namespaces';
import { assertNodeOfPossibleTypes } from './node_assert';
import { writeDirectClass } from './node_manipulation';
import { extractAttrsAndClassesFromSelector, stringifyCSSSelectorList } from './node_selector_matcher';
import { enterView, leaveView } from './state';
import { setUpAttributes } from './util/attrs_utils';
import { defaultScheduler } from './util/misc_utils';
import { getTNode } from './util/view_utils';
import { createElementRef } from './view_engine_compatibility';
import { RootViewRef } from './view_ref';
export class ComponentFactoryResolver extends viewEngine_ComponentFactoryResolver {
/**
* @param {?=} ngModule The NgModuleRef to which all resolved factories are bound.
*/
constructor(ngModule) {
super();
this.ngModule = ngModule;
}
/**
* @template T
* @param {?} component
* @return {?}
*/
resolveComponentFactory(component) {
ngDevMode && assertComponentType(component);
/** @type {?} */
const componentDef = (/** @type {?} */ (getComponentDef(component)));
return new ComponentFactory(componentDef, this.ngModule);
}
}
if (false) {
/**
* @type {?}
* @private
*/
ComponentFactoryResolver.prototype.ngModule;
}
/**
* @param {?} map
* @return {?}
*/
function toRefArray(map) {
/** @type {?} */
const array = [];
for (let nonMinified in map) {
if (map.hasOwnProperty(nonMinified)) {
/** @type {?} */
const minified = map[nonMinified];
array.push({ propName: minified, templateName: nonMinified });
}
}
return array;
}
/**
* @param {?} elementName
* @return {?}
*/
function getNamespace(elementName) {
/** @type {?} */
const name = elementName.toLowerCase();
return name === 'svg' ? SVG_NAMESPACE : (name === 'math' ? MATH_ML_NAMESPACE : null);
}
/**
* A change detection scheduler token for {\@link RootContext}. This token is the default value used
* for the default `RootContext` found in the {\@link ROOT_CONTEXT} token.
* @type {?}
*/
export const SCHEDULER = new InjectionToken('SCHEDULER_TOKEN', {
providedIn: 'root',
factory: (/**
* @return {?}
*/
() => defaultScheduler),
});
/**
* @param {?} rootViewInjector
* @param {?} moduleInjector
* @return {?}
*/
function createChainedInjector(rootViewInjector, moduleInjector) {
return {
get: (/**
* @template T
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
(token, notFoundValue, flags) => {
/** @type {?} */
const value = rootViewInjector.get(token, (/** @type {?} */ (NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)), flags);
if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR ||
notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {
// Return the value from the root element injector when
// - it provides it
// (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)
// - the module injector should not be checked
// (notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)
return value;
}
return moduleInjector.get(token, notFoundValue, flags);
})
};
}
/**
* Render3 implementation of {\@link viewEngine_ComponentFactory}.
* @template T
*/
export class ComponentFactory extends viewEngine_ComponentFactory {
/**
* @param {?} componentDef The component definition.
* @param {?=} ngModule The NgModuleRef to which the factory is bound.
*/
constructor(componentDef, ngModule) {
super();
this.componentDef = componentDef;
this.ngModule = ngModule;
this.componentType = componentDef.type;
this.selector = stringifyCSSSelectorList(componentDef.selectors);
this.ngContentSelectors =
componentDef.ngContentSelectors ? componentDef.ngContentSelectors : [];
this.isBoundToModule = !!ngModule;
}
/**
* @return {?}
*/
get inputs() {
return toRefArray(this.componentDef.inputs);
}
/**
* @return {?}
*/
get outputs() {
return toRefArray(this.componentDef.outputs);
}
/**
* @param {?} injector
* @param {?=} projectableNodes
* @param {?=} rootSelectorOrNode
* @param {?=} ngModule
* @return {?}
*/
create(injector, projectableNodes, rootSelectorOrNode, ngModule) {
ngModule = ngModule || this.ngModule;
/** @type {?} */
const rootViewInjector = ngModule ? createChainedInjector(injector, ngModule.injector) : injector;
/** @type {?} */
const rendererFactory = (/** @type {?} */ (rootViewInjector.get(RendererFactory2, domRendererFactory3)));
/** @type {?} */
const sanitizer = rootViewInjector.get(Sanitizer, null);
/** @type {?} */
const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
// Determine a tag name used for creating host elements when this component is created
// dynamically. Default to 'div' if this component did not specify any tag name in its selector.
/** @type {?} */
const elementName = (/** @type {?} */ (this.componentDef.selectors[0][0])) || 'div';
/** @type {?} */
const hostRNode = rootSelectorOrNode ?
locateHostElement(hostRenderer, rootSelectorOrNode, this.componentDef.encapsulation) :
elementCreate(elementName, rendererFactory.createRenderer(null, this.componentDef), getNamespace(elementName));
/** @type {?} */
const rootFlags = this.componentDef.onPush ? 64 /* Dirty */ | 512 /* IsRoot */ :
16 /* CheckAlways */ | 512 /* IsRoot */;
// Check whether this Component needs to be isolated from other components, i.e. whether it
// should be placed into its own (empty) root context or existing root context should be used.
// Note: this is internal-only convention and might change in the future, so it should not be
// relied upon externally.
/** @type {?} */
const isIsolated = typeof rootSelectorOrNode === 'string' &&
/^#root-ng-internal-isolated-\d+/.test(rootSelectorOrNode);
/** @type {?} */
const rootContext = createRootContext();
// Create the root view. Uses empty TView and ContentTemplate.
/** @type {?} */
const rootTView = createTView(0 /* Root */, -1, null, 1, 0, null, null, null, null, null);
/** @type {?} */
const rootLView = createLView(null, rootTView, rootContext, rootFlags, null, null, rendererFactory, hostRenderer, sanitizer, rootViewInjector);
// rootView is the parent when bootstrapping
// TODO(misko): it looks like we are entering view here but we don't really need to as
// `renderView` does that. However as the code is written it is needed because
// `createRootComponentView` and `createRootComponent` both read global state. Fixing those
// issues would allow us to drop this.
enterView(rootLView, null);
/** @type {?} */
let component;
/** @type {?} */
let tElementNode;
try {
/** @type {?} */
const componentView = createRootComponentView(hostRNode, this.componentDef, rootLView, rendererFactory, hostRenderer);
if (hostRNode) {
if (rootSelectorOrNode) {
setUpAttributes(hostRenderer, hostRNode, ['ng-version', VERSION.full]);
}
else {
// If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
// is not defined), also apply attributes and classes extracted from component selector.
// Extract attributes and classes from the first selector only to match VE behavior.
const { attrs, classes } = extractAttrsAndClassesFromSelector(this.componentDef.selectors[0]);
if (attrs) {
setUpAttributes(hostRenderer, hostRNode, attrs);
}
if (classes && classes.length > 0) {
writeDirectClass(hostRenderer, hostRNode, classes.join(' '));
}
}
}
tElementNode = (/** @type {?} */ (getTNode(rootTView, 0)));
if (projectableNodes !== undefined) {
/** @type {?} */
const projection = tElementNode.projection = [];
for (let i = 0; i < this.ngContentSelectors.length; i++) {
/** @type {?} */
const nodesforSlot = projectableNodes[i];
// Projectable nodes can be passed as array of arrays or an array of iterables (ngUpgrade
// case). Here we do normalize passed data structure to be an array of arrays to avoid
// complex checks down the line.
// We also normalize the length of the passed in projectable nodes (to match the number of
// <ng-container> slots defined by a component).
projection.push(nodesforSlot != null ? Array.from(nodesforSlot) : null);
}
}
// TODO: should LifecycleHooksFeature and other host features be generated by the compiler and
// executed here?
// Angular 5 reference: https://stackblitz.com/edit/lifecycle-hooks-vcref
component = createRootComponent(componentView, this.componentDef, rootLView, rootContext, [LifecycleHooksFeature]);
renderView(rootTView, rootLView, null);
}
finally {
leaveView();
}
/** @type {?} */
const componentRef = new ComponentRef(this.componentType, component, createElementRef(viewEngine_ElementRef, tElementNode, rootLView), rootLView, tElementNode);
if (!rootSelectorOrNode || isIsolated) {
// The host element of the internal or isolated root view is attached to the component's host
// view node.
ngDevMode && assertNodeOfPossibleTypes(rootTView.node, 2 /* View */);
(/** @type {?} */ (rootTView.node)).child = tElementNode;
}
return componentRef;
}
}
if (false) {
/** @type {?} */
ComponentFactory.prototype.selector;
/** @type {?} */
ComponentFactory.prototype.componentType;
/** @type {?} */
ComponentFactory.prototype.ngContentSelectors;
/** @type {?} */
ComponentFactory.prototype.isBoundToModule;
/**
* @type {?}
* @private
*/
ComponentFactory.prototype.componentDef;
/**
* @type {?}
* @private
*/
ComponentFactory.prototype.ngModule;
}
/** @type {?} */
const componentFactoryResolver = new ComponentFactoryResolver();
/**
* Creates a ComponentFactoryResolver and stores it on the injector. Or, if the
* ComponentFactoryResolver
* already exists, retrieves the existing ComponentFactoryResolver.
*
* @return {?} The ComponentFactoryResolver instance to use
*/
export function injectComponentFactoryResolver() {
return componentFactoryResolver;
}
/**
* Represents an instance of a Component created via a {\@link ComponentFactory}.
*
* `ComponentRef` provides access to the Component Instance as well other objects related to this
* Component Instance and allows you to destroy the Component Instance via the {\@link #destroy}
* method.
*
* @template T
*/
export class ComponentRef extends viewEngine_ComponentRef {
/**
* @param {?} componentType
* @param {?} instance
* @param {?} location
* @param {?} _rootLView
* @param {?} _tNode
*/
constructor(componentType, instance, location, _rootLView, _tNode) {
super();
this.location = location;
this._rootLView = _rootLView;
this._tNode = _tNode;
this.destroyCbs = [];
this.instance = instance;
this.hostView = this.changeDetectorRef = new RootViewRef(_rootLView);
assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);
this.componentType = componentType;
}
/**
* @return {?}
*/
get injector() {
return new NodeInjector(this._tNode, this._rootLView);
}
/**
* @return {?}
*/
destroy() {
if (this.destroyCbs) {
this.destroyCbs.forEach((/**
* @param {?} fn
* @return {?}
*/
fn => fn()));
this.destroyCbs = null;
!this.hostView.destroyed && this.hostView.destroy();
}
}
/**
* @param {?} callback
* @return {?}
*/
onDestroy(callback) {
if (this.destroyCbs) {
this.destroyCbs.push(callback);
}
}
}
if (false) {
/** @type {?} */
ComponentRef.prototype.destroyCbs;
/** @type {?} */
ComponentRef.prototype.instance;
/** @type {?} */
ComponentRef.prototype.hostView;
/** @type {?} */
ComponentRef.prototype.changeDetectorRef;
/** @type {?} */
ComponentRef.prototype.componentType;
/** @type {?} */
ComponentRef.prototype.location;
/**
* @type {?}
* @private
*/
ComponentRef.prototype._rootLView;
/**
* @type {?}
* @private
*/
ComponentRef.prototype._tNode;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component_ref.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/component_ref.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 {InjectionToken} from '../di/injection_token';\nimport {Injector} from '../di/injector';\nimport {InjectFlags} from '../di/interface/injector';\nimport {Type} from '../interface/type';\nimport {ComponentFactory as viewEngine_ComponentFactory, ComponentRef as viewEngine_ComponentRef} from '../linker/component_factory';\nimport {ComponentFactoryResolver as viewEngine_ComponentFactoryResolver} from '../linker/component_factory_resolver';\nimport {ElementRef as viewEngine_ElementRef} from '../linker/element_ref';\nimport {NgModuleRef as viewEngine_NgModuleRef} from '../linker/ng_module_factory';\nimport {RendererFactory2} from '../render/api';\nimport {Sanitizer} from '../sanitization/sanitizer';\nimport {VERSION} from '../version';\nimport {NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR} from '../view/provider';\n\nimport {assertComponentType} from './assert';\nimport {createRootComponent, createRootComponentView, createRootContext, LifecycleHooksFeature} from './component';\nimport {getComponentDef} from './definition';\nimport {NodeInjector} from './di';\nimport {assignTViewNodeToLView, createLView, createTView, elementCreate, locateHostElement, renderView} from './instructions/shared';\nimport {ComponentDef} from './interfaces/definition';\nimport {TContainerNode, TElementContainerNode, TElementNode, TNode, TNodeType} from './interfaces/node';\nimport {domRendererFactory3, RendererFactory3, RNode} from './interfaces/renderer';\nimport {LView, LViewFlags, TVIEW, TViewType} from './interfaces/view';\nimport {MATH_ML_NAMESPACE, SVG_NAMESPACE} from './namespaces';\nimport {assertNodeOfPossibleTypes} from './node_assert';\nimport {writeDirectClass} from './node_manipulation';\nimport {extractAttrsAndClassesFromSelector, stringifyCSSSelectorList} from './node_selector_matcher';\nimport {enterView, leaveView} from './state';\nimport {setUpAttributes} from './util/attrs_utils';\nimport {defaultScheduler} from './util/misc_utils';\nimport {getTNode} from './util/view_utils';\nimport {createElementRef} from './view_engine_compatibility';\nimport {RootViewRef, ViewRef} from './view_ref';\n\nexport class ComponentFactoryResolver extends viewEngine_ComponentFactoryResolver {\n  /**\n   * @param ngModule The NgModuleRef to which all resolved factories are bound.\n   */\n  constructor(private ngModule?: viewEngine_NgModuleRef<any>) {\n    super();\n  }\n\n  resolveComponentFactory<T>(component: Type<T>): viewEngine_ComponentFactory<T> {\n    ngDevMode && assertComponentType(component);\n    const componentDef = getComponentDef(component)!;\n    return new ComponentFactory(componentDef, this.ngModule);\n  }\n}\n\nfunction toRefArray(map: {[key: string]: string}): {propName: string; templateName: string;}[] {\n  const array: {propName: string; templateName: string;}[] = [];\n  for (let nonMinified in map) {\n    if (map.hasOwnProperty(nonMinified)) {\n      const minified = map[nonMinified];\n      array.push({propName: minified, templateName: nonMinified});\n    }\n  }\n  return array;\n}\n\nfunction getNamespace(elementName: string): string|null {\n  const name = elementName.toLowerCase();\n  return name === 'svg' ? SVG_NAMESPACE : (name === 'math' ? MATH_ML_NAMESPACE : null);\n}\n\n/**\n * A change detection scheduler token for {@link RootContext}. This token is the default value used\n * for the default `RootContext` found in the {@link ROOT_CONTEXT} token.\n */\nexport const SCHEDULER = new InjectionToken<((fn: () => void) => void)>('SCHEDULER_TOKEN', {\n  providedIn: 'root',\n  factory: () => defaultScheduler,\n});\n\nfunction createChainedInjector(rootViewInjector: Injector, moduleInjector: Injector): Injector {\n  return {\n    get: <T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T, flags?: InjectFlags): T => {\n      const value = rootViewInjector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as T, flags);\n\n      if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR ||\n          notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {\n        // Return the value from the root element injector when\n        // - it provides it\n        //   (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n        // - the module injector should not be checked\n        //   (notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n        return value;\n      }\n\n      return moduleInjector.get(token, notFoundValue, flags);\n    }\n  };\n}\n\n/**\n * Render3 implementation of {@link viewEngine_ComponentFactory}.\n */\nexport class ComponentFactory<T> extends viewEngine_ComponentFactory<T> {\n  selector: string;\n  componentType: Type<any>;\n  ngContentSelectors: string[];\n  isBoundToModule: boolean;\n\n  get inputs(): {propName: string; templateName: string;}[] {\n    return toRefArray(this.componentDef.inputs);\n  }\n\n  get outputs(): {propName: string; templateName: string;}[] {\n    return toRefArray(this.componentDef.outputs);\n  }\n\n  /**\n   * @param componentDef The component definition.\n   * @param ngModule The NgModuleRef to which the factory is bound.\n   */\n  constructor(\n      private componentDef: ComponentDef<any>, private ngModule?: viewEngine_NgModuleRef<any>) {\n    super();\n    this.componentType = componentDef.type;\n    this.selector = stringifyCSSSelectorList(componentDef.selectors);\n    this.ngContentSelectors =\n        componentDef.ngContentSelectors ? componentDef.ngContentSelectors : [];\n    this.isBoundToModule = !!ngModule;\n  }\n\n  create(\n      injector: Injector, projectableNodes?: any[][]|undefined, rootSelectorOrNode?: any,\n      ngModule?: viewEngine_NgModuleRef<any>|undefined): viewEngine_ComponentRef<T> {\n    ngModule = ngModule || this.ngModule;\n\n    const rootViewInjector =\n        ngModule ? createChainedInjector(injector, ngModule.injector) : injector;\n\n    const rendererFactory =\n        rootViewInjector.get(RendererFactory2, domRendererFactory3) as RendererFactory3;\n    const sanitizer = rootViewInjector.get(Sanitizer, null);\n\n    const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);\n    // Determine a tag name used for creating host elements when this component is created\n    // dynamically. Default to 'div' if this component did not specify any tag name in its selector.\n    const elementName = this.componentDef.selectors[0][0] as string || 'div';\n    const hostRNode = rootSelectorOrNode ?\n        locateHostElement(hostRenderer, rootSelectorOrNode, this.componentDef.encapsulation) :\n        elementCreate(\n            elementName, rendererFactory.createRenderer(null, this.componentDef),\n            getNamespace(elementName));\n\n    const rootFlags = this.componentDef.onPush ? LViewFlags.Dirty | LViewFlags.IsRoot :\n                                                 LViewFlags.CheckAlways | LViewFlags.IsRoot;\n\n    // Check whether this Component needs to be isolated from other components, i.e. whether it\n    // should be placed into its own (empty) root context or existing root context should be used.\n    // Note: this is internal-only convention and might change in the future, so it should not be\n    // relied upon externally.\n    const isIsolated = typeof rootSelectorOrNode === 'string' &&\n        /^#root-ng-internal-isolated-\\d+/.test(rootSelectorOrNode);\n\n    const rootContext = createRootContext();\n\n    // Create the root view. Uses empty TView and ContentTemplate.\n    const rootTView = createTView(TViewType.Root, -1, null, 1, 0, null, null, null, null, null);\n    const rootLView = createLView(\n        null, rootTView, rootContext, rootFlags, null, null, rendererFactory, hostRenderer,\n        sanitizer, rootViewInjector);\n\n    // rootView is the parent when bootstrapping\n    // TODO(misko): it looks like we are entering view here but we don't really need to as\n    // `renderView` does that. However as the code is written it is needed because\n    // `createRootComponentView` and `createRootComponent` both read global state. Fixing those\n    // issues would allow us to drop this.\n    enterView(rootLView, null);\n\n    let component: T;\n    let tElementNode: TElementNode;\n\n    try {\n      const componentView = createRootComponentView(\n          hostRNode, this.componentDef, rootLView, rendererFactory, hostRenderer);\n      if (hostRNode) {\n        if (rootSelectorOrNode) {\n          setUpAttributes(hostRenderer, hostRNode, ['ng-version', VERSION.full]);\n        } else {\n          // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`\n          // is not defined), also apply attributes and classes extracted from component selector.\n          // Extract attributes and classes from the first selector only to match VE behavior.\n          const {attrs, classes} =\n              extractAttrsAndClassesFromSelector(this.componentDef.selectors[0]);\n          if (attrs) {\n            setUpAttributes(hostRenderer, hostRNode, attrs);\n          }\n          if (classes && classes.length > 0) {\n            writeDirectClass(hostRenderer, hostRNode, classes.join(' '));\n          }\n        }\n      }\n\n      tElementNode = getTNode(rootTView, 0) as TElementNode;\n\n      if (projectableNodes !== undefined) {\n        const projection: (TNode|RNode[]|null)[] = tElementNode.projection = [];\n        for (let i = 0; i < this.ngContentSelectors.length; i++) {\n          const nodesforSlot = projectableNodes[i];\n          // Projectable nodes can be passed as array of arrays or an array of iterables (ngUpgrade\n          // case). Here we do normalize passed data structure to be an array of arrays to avoid\n          // complex checks down the line.\n          // We also normalize the length of the passed in projectable nodes (to match the number of\n          // <ng-container> slots defined by a component).\n          projection.push(nodesforSlot != null ? Array.from(nodesforSlot) : null);\n        }\n      }\n\n      // TODO: should LifecycleHooksFeature and other host features be generated by the compiler and\n      // executed here?\n      // Angular 5 reference: https://stackblitz.com/edit/lifecycle-hooks-vcref\n      component = createRootComponent(\n          componentView, this.componentDef, rootLView, rootContext, [LifecycleHooksFeature]);\n\n      renderView(rootTView, rootLView, null);\n    } finally {\n      leaveView();\n    }\n\n    const componentRef = new ComponentRef(\n        this.componentType, component,\n        createElementRef(viewEngine_ElementRef, tElementNode, rootLView), rootLView, tElementNode);\n\n    if (!rootSelectorOrNode || isIsolated) {\n      // The host element of the internal or isolated root view is attached to the component's host\n      // view node.\n      ngDevMode && assertNodeOfPossibleTypes(rootTView.node, TNodeType.View);\n      rootTView.node!.child = tElementNode;\n    }\n    return componentRef;\n  }\n}\n\nconst componentFactoryResolver: ComponentFactoryResolver = new ComponentFactoryResolver();\n\n/**\n * Creates a ComponentFactoryResolver and stores it on the injector. Or, if the\n * ComponentFactoryResolver\n * already exists, retrieves the existing ComponentFactoryResolver.\n *\n * @returns The ComponentFactoryResolver instance to use\n */\nexport function injectComponentFactoryResolver(): viewEngine_ComponentFactoryResolver {\n  return componentFactoryResolver;\n}\n\n/**\n * Represents an instance of a Component created via a {@link ComponentFactory}.\n *\n * `ComponentRef` provides access to the Component Instance as well other objects related to this\n * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}\n * method.\n *\n */\nexport class ComponentRef<T> extends viewEngine_ComponentRef<T> {\n  destroyCbs: (() => void)[]|null = [];\n  instance: T;\n  hostView: ViewRef<T>;\n  changeDetectorRef: ViewEngine_ChangeDetectorRef;\n  componentType: Type<T>;\n\n  constructor(\n      componentType: Type<T>, instance: T, public location: viewEngine_ElementRef,\n      private _rootLView: LView,\n      private _tNode: TElementNode|TContainerNode|TElementContainerNode) {\n    super();\n    this.instance = instance;\n    this.hostView = this.changeDetectorRef = new RootViewRef<T>(_rootLView);\n    assignTViewNodeToLView(_rootLView[TVIEW], null, -1, _rootLView);\n    this.componentType = componentType;\n  }\n\n  get injector(): Injector {\n    return new NodeInjector(this._tNode, this._rootLView);\n  }\n\n  destroy(): void {\n    if (this.destroyCbs) {\n      this.destroyCbs.forEach(fn => fn());\n      this.destroyCbs = null;\n      !this.hostView.destroyed && this.hostView.destroy();\n    }\n  }\n\n  onDestroy(callback: () => void): void {\n    if (this.destroyCbs) {\n      this.destroyCbs.push(callback);\n    }\n  }\n}\n"]}