@angular/core 7.2.0-beta.0 → 7.2.0

package/esm2015/src/render3/assert.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -10,6 +10,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { getComponentDef, getNgModuleDef } from './definition';
+// The functions in this file verify that the assumptions we are making
+// about state in an instruction are correct before implementing any logic.
+// They are meant only to be called in dev mode as sanity checks.
 /**
  * @param {?} actual
  * @param {?} msg
@@ -138,5 +141,37 @@ function throwError(msg) {
 export function assertDomNode(node) {
     assertEqual(node instanceof Node, true, 'The provided value must be an instance of a DOM Node');
 }
-
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * @param {?} isParent
+ * @return {?}
+ */
+export function assertPreviousIsParent(isParent) {
+    assertEqual(isParent, true, 'previousOrParentTNode should be a parent');
+}
+/**
+ * @param {?} tNode
+ * @return {?}
+ */
+export function assertHasParent(tNode) {
+    assertDefined(tNode.parent, 'previousOrParentTNode should have a parent');
+}
+/**
+ * @param {?} lView
+ * @param {?} index
+ * @param {?=} arr
+ * @return {?}
+ */
+export function assertDataNext(lView, index, arr) {
+    if (arr == null)
+        arr = lView;
+    assertEqual(arr.length, index, `index ${index} expected to be at the end of arr (length ${arr.length})`);
+}
+/**
+ * @param {?} arr
+ * @param {?} index
+ * @return {?}
+ */
+export function assertDataInRange(arr, index) {
+    assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/render3/bindings.js

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,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 { devModeEqual } from '../change_detection/change_detection_util';
+import { assertDataInRange, assertLessThan, assertNotEqual } from './assert';
+import { throwErrorIfNoChangesMode } from './errors';
+import { getCheckNoChangesMode, isCreationMode } from './state';
+import { NO_CHANGE } from './tokens';
+import { isDifferent } from './util';
+// TODO(misko): consider inlining
+/**
+ * Updates binding and returns the value.
+ * @param {?} lView
+ * @param {?} bindingIndex
+ * @param {?} value
+ * @return {?}
+ */
+export function updateBinding(lView, bindingIndex, value) {
+    return lView[bindingIndex] = value;
+}
+/**
+ * Gets the current binding value.
+ * @param {?} lView
+ * @param {?} bindingIndex
+ * @return {?}
+ */
+export function getBinding(lView, bindingIndex) {
+    ngDevMode && assertDataInRange(lView, lView[bindingIndex]);
+    ngDevMode &&
+        assertNotEqual(lView[bindingIndex], NO_CHANGE, 'Stored value should never be NO_CHANGE.');
+    return lView[bindingIndex];
+}
+/**
+ * Updates binding if changed, then returns whether it was updated.
+ * @param {?} lView
+ * @param {?} bindingIndex
+ * @param {?} value
+ * @return {?}
+ */
+export function bindingUpdated(lView, bindingIndex, value) {
+    ngDevMode && assertNotEqual(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
+    ngDevMode &&
+        assertLessThan(bindingIndex, lView.length, `Slot should have been initialized to NO_CHANGE`);
+    if (lView[bindingIndex] === NO_CHANGE) {
+        // initial pass
+        lView[bindingIndex] = value;
+    }
+    else if (isDifferent(lView[bindingIndex], value)) {
+        if (ngDevMode && getCheckNoChangesMode()) {
+            if (!devModeEqual(lView[bindingIndex], value)) {
+                throwErrorIfNoChangesMode(isCreationMode(lView), lView[bindingIndex], value);
+            }
+        }
+        lView[bindingIndex] = value;
+    }
+    else {
+        return false;
+    }
+    return true;
+}
+/**
+ * Updates 2 bindings if changed, then returns whether either was updated.
+ * @param {?} lView
+ * @param {?} bindingIndex
+ * @param {?} exp1
+ * @param {?} exp2
+ * @return {?}
+ */
+export function bindingUpdated2(lView, bindingIndex, exp1, exp2) {
+    /** @type {?} */
+    const different = bindingUpdated(lView, bindingIndex, exp1);
+    return bindingUpdated(lView, bindingIndex + 1, exp2) || different;
+}
+/**
+ * Updates 3 bindings if changed, then returns whether any was updated.
+ * @param {?} lView
+ * @param {?} bindingIndex
+ * @param {?} exp1
+ * @param {?} exp2
+ * @param {?} exp3
+ * @return {?}
+ */
+export function bindingUpdated3(lView, bindingIndex, exp1, exp2, exp3) {
+    /** @type {?} */
+    const different = bindingUpdated2(lView, bindingIndex, exp1, exp2);
+    return bindingUpdated(lView, bindingIndex + 2, exp3) || different;
+}
+/**
+ * Updates 4 bindings if changed, then returns whether any was updated.
+ * @param {?} lView
+ * @param {?} bindingIndex
+ * @param {?} exp1
+ * @param {?} exp2
+ * @param {?} exp3
+ * @param {?} exp4
+ * @return {?}
+ */
+export function bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) {
+    /** @type {?} */
+    const different = bindingUpdated2(lView, bindingIndex, exp1, exp2);
+    return bindingUpdated2(lView, bindingIndex + 2, exp3, exp4) || different;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/render3/component.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -14,72 +14,73 @@ import { getComponentDef } from './definition';
 import { diPublicInInjector, getOrCreateNodeInjectorForNode } from './di';
 import { publishDefaultGlobalUtils } from './global_utils';
 import { queueInitHooks, queueLifecycleHooks } from './hooks';
-import { CLEAN_PROMISE, createLViewData, createNodeAtIndex, createTView, getOrCreateTView, initNodeFlags, instantiateRootComponent, locateHostElement, prefillHostVars, queueComponentIndexForCheck, refreshDescendantViews } from './instructions';
+import { CLEAN_PROMISE, createLView, createNodeAtIndex, createTView, getOrCreateTView, initNodeFlags, instantiateRootComponent, locateHostElement, queueComponentIndexForCheck, refreshDescendantViews } from './instructions';
 import { domRendererFactory3 } from './interfaces/renderer';
-import { CONTEXT, HEADER_OFFSET, HOST, HOST_NODE, TVIEW } from './interfaces/view';
-import { enterView, leaveView, resetComponentState } from './state';
-import { defaultScheduler, getRootView, readPatchedLViewData, stringify } from './util';
+import { CONTEXT, FLAGS, HEADER_OFFSET, HOST, HOST_NODE, TVIEW } from './interfaces/view';
+import { enterView, getPreviousOrParentTNode, leaveView, resetComponentState, setCurrentDirectiveDef } from './state';
+import { defaultScheduler, getRootView, readPatchedLView, stringify } from './util';
 /**
  * Options that control how the component should be bootstrapped.
  * @record
  */
 export function CreateComponentOptions() { }
-/**
- * Which renderer factory to use.
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.rendererFactory;
-/**
- * A custom sanitizer instance
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.sanitizer;
-/**
- * A custom animation player handler
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.playerHandler;
-/**
- * Host element on which the component will be bootstrapped. If not specified,
- * the component definition's `tag` is used to query the existing DOM for the
- * element to bootstrap.
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.host;
-/**
- * Module injector for the component. If unspecified, the injector will be NULL_INJECTOR.
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.injector;
-/**
- * List of features to be applied to the created component. Features are simply
- * functions that decorate a component with a certain behavior.
- *
- * Typically, the features in this list are features that cannot be added to the
- * other features list in the component definition because they rely on other factors.
- *
- * Example: `RootLifecycleHooks` is a function that adds lifecycle hook capabilities
- * to root components in a tree-shakable way. It cannot be added to the component
- * features list because there's no way of knowing when the component will be used as
- * a root component.
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.hostFeatures;
-/**
- * A function which is used to schedule change detection work in the future.
- *
- * When marking components as dirty, it is necessary to schedule the work of
- * change detection in the future. This is done to coalesce multiple
- * {\@link markDirty} calls into a single changed detection processing.
- *
- * The default value of the scheduler is the `requestAnimationFrame` function.
- *
- * It is also useful to override this function for testing purposes.
- * @type {?|undefined}
- */
-CreateComponentOptions.prototype.scheduler;
-/** @typedef {?} */
-var HostFeature;
+if (false) {
+    /**
+     * Which renderer factory to use.
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.rendererFactory;
+    /**
+     * A custom sanitizer instance
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.sanitizer;
+    /**
+     * A custom animation player handler
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.playerHandler;
+    /**
+     * Host element on which the component will be bootstrapped. If not specified,
+     * the component definition's `tag` is used to query the existing DOM for the
+     * element to bootstrap.
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.host;
+    /**
+     * Module injector for the component. If unspecified, the injector will be NULL_INJECTOR.
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.injector;
+    /**
+     * List of features to be applied to the created component. Features are simply
+     * functions that decorate a component with a certain behavior.
+     *
+     * Typically, the features in this list are features that cannot be added to the
+     * other features list in the component definition because they rely on other factors.
+     *
+     * Example: `RootLifecycleHooks` is a function that adds lifecycle hook capabilities
+     * to root components in a tree-shakable way. It cannot be added to the component
+     * features list because there's no way of knowing when the component will be used as
+     * a root component.
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.hostFeatures;
+    /**
+     * A function which is used to schedule change detection work in the future.
+     *
+     * When marking components as dirty, it is necessary to schedule the work of
+     * change detection in the future. This is done to coalesce multiple
+     * {\@link markDirty} calls into a single changed detection processing.
+     *
+     * The default value of the scheduler is the `requestAnimationFrame` function.
+     *
+     * It is also useful to override this function for testing purposes.
+     * @type {?|undefined}
+     */
+    CreateComponentOptions.prototype.scheduler;
+}
+// TODO: A hack to not pull in the NullInjector from @angular/core.
 /** @type {?} */
 export const NULL_INJECTOR = {
     get: (token, notFoundValue) => {
@@ -109,22 +110,23 @@ export function renderComponent(componentType /* Type as workaround for: Microso
     /** @type {?} */
     const sanitizer = opts.sanitizer || null;
     /** @type {?} */
-    const componentDef = /** @type {?} */ ((getComponentDef(componentType)));
+    const componentDef = (/** @type {?} */ (getComponentDef(componentType)));
     if (componentDef.type != componentType)
         componentDef.type = componentType;
+    // The first index of the first selector is the tag name.
     /** @type {?} */
-    const componentTag = /** @type {?} */ (((/** @type {?} */ ((componentDef.selectors))[0]))[0]);
+    const componentTag = (/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (componentDef.selectors))[0]))[0]));
     /** @type {?} */
     const hostRNode = locateHostElement(rendererFactory, opts.host || componentTag);
     /** @type {?} */
-    const rootFlags = componentDef.onPush ? 4 /* Dirty */ | 64 /* IsRoot */ :
-        2 /* CheckAlways */ | 64 /* IsRoot */;
+    const rootFlags = componentDef.onPush ? 8 /* Dirty */ | 128 /* IsRoot */ :
+        4 /* CheckAlways */ | 128 /* IsRoot */;
     /** @type {?} */
     const rootContext = createRootContext(opts.scheduler, opts.playerHandler);
     /** @type {?} */
     const renderer = rendererFactory.createRenderer(hostRNode, componentDef);
     /** @type {?} */
-    const rootView = createLViewData(null, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, rendererFactory, renderer, undefined, opts.injector || null);
+    const rootView = createLView(null, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, rendererFactory, renderer, undefined, opts.injector || null);
     /** @type {?} */
     const oldView = enterView(rootView, null);
     /** @type {?} */
@@ -135,7 +137,9 @@ export function renderComponent(componentType /* Type as workaround for: Microso
         /** @type {?} */
         const componentView = createRootComponentView(hostRNode, componentDef, rootView, rendererFactory, renderer, sanitizer);
         component = createRootComponent(componentView, componentDef, rootView, rootContext, opts.hostFeatures || null);
-        refreshDescendantViews(rootView, null);
+        refreshDescendantViews(rootView); // creation mode pass
+        rootView[FLAGS] &= ~1 /* CreationMode */;
+        refreshDescendantViews(rootView); // update mode pass
     }
     finally {
         leaveView(oldView);
@@ -161,18 +165,18 @@ export function createRootComponentView(rNode, def, rootView, rendererFactory, r
     /** @type {?} */
     const tView = rootView[TVIEW];
     /** @type {?} */
-    const componentView = createLViewData(rootView, getOrCreateTView(def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery), null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */, rendererFactory, renderer, sanitizer);
+    const componentView = createLView(rootView, getOrCreateTView(def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery), null, def.onPush ? 8 /* Dirty */ : 4 /* CheckAlways */, rendererFactory, renderer, sanitizer);
     /** @type {?} */
     const tNode = createNodeAtIndex(0, 3 /* Element */, rNode, null, null);
     if (tView.firstTemplatePass) {
         diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, rootView), rootView, def.type);
-        tNode.flags = 4096 /* isComponent */;
+        tNode.flags = 1 /* isComponent */;
         initNodeFlags(tNode, rootView.length, 1);
         queueComponentIndexForCheck(tNode);
     }
     // Store component view at node index, with node as the HOST
     componentView[HOST] = rootView[HEADER_OFFSET];
-    componentView[HOST_NODE] = /** @type {?} */ (tNode);
+    componentView[HOST_NODE] = (/** @type {?} */ (tNode));
     return rootView[HEADER_OFFSET] = componentView;
 }
 /**
@@ -189,13 +193,19 @@ export function createRootComponentView(rNode, def, rootView, rendererFactory, r
 export function createRootComponent(componentView, componentDef, rootView, rootContext, hostFeatures) {
     /** @type {?} */
     const tView = rootView[TVIEW];
+    // Create directive instance with factory() and store at next index in viewData
     /** @type {?} */
     const component = instantiateRootComponent(tView, rootView, componentDef);
     rootContext.components.push(component);
     componentView[CONTEXT] = component;
     hostFeatures && hostFeatures.forEach((feature) => feature(component, componentDef));
-    if (tView.firstTemplatePass)
-        prefillHostVars(tView, rootView, componentDef.hostVars);
+    if (tView.firstTemplatePass && componentDef.hostBindings) {
+        /** @type {?} */
+        const rootTNode = getPreviousOrParentTNode();
+        setCurrentDirectiveDef(componentDef);
+        componentDef.hostBindings(1 /* Create */, component, rootTNode.index - HEADER_OFFSET);
+        setCurrentDirectiveDef(null);
+    }
     return component;
 }
 /**
@@ -230,11 +240,13 @@ export function createRootContext(scheduler, playerHandler) {
  */
 export function LifecycleHooksFeature(component, def) {
     /** @type {?} */
-    const rootTView = /** @type {?} */ ((readPatchedLViewData(component)))[TVIEW];
+    const rootTView = (/** @type {?} */ (readPatchedLView(component)))[TVIEW];
     /** @type {?} */
     const dirIndex = rootTView.data.length - 1;
     queueInitHooks(dirIndex, def.onInit, def.doCheck, rootTView);
-    queueLifecycleHooks(dirIndex << 16 /* DirectiveStartingIndexShift */ | 1, rootTView);
+    // TODO(misko): replace `as TNode` with createTNode call. (needs refactoring to lose dep on
+    // LNode).
+    queueLifecycleHooks(rootTView, (/** @type {?} */ ({ directiveStart: dirIndex, directiveEnd: dirIndex + 1 })));
 }
 /**
  * Retrieve the root context for any component by walking the parent `LView` until
@@ -245,7 +257,7 @@ export function LifecycleHooksFeature(component, def) {
  */
 function getRootContext(component) {
     /** @type {?} */
-    const rootContext = /** @type {?} */ (getRootView(component)[CONTEXT]);
+    const rootContext = (/** @type {?} */ (getRootView(component)[CONTEXT]));
     ngDevMode && assertDefined(rootContext, 'rootContext');
     return rootContext;
 }
@@ -268,5 +280,4 @@ function getRootContext(component) {
 export function whenRendered(component) {
     return getRootContext(component).clean;
 }
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/component.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\n// We are temporarily importing the existing viewEngine from core so we can be sure we are\n// correctly implementing its interfaces for backwards compatibility.\nimport {Type} from '../core';\nimport {Injector} from '../di/injector';\nimport {Sanitizer} from '../sanitization/security';\n\nimport {assertComponentType, assertDefined} from './assert';\nimport {getComponentDef} from './definition';\nimport {diPublicInInjector, getOrCreateNodeInjectorForNode} from './di';\nimport {publishDefaultGlobalUtils} from './global_utils';\nimport {queueInitHooks, queueLifecycleHooks} from './hooks';\nimport {CLEAN_PROMISE, createLViewData, createNodeAtIndex, createTView, getOrCreateTView, initNodeFlags, instantiateRootComponent, locateHostElement, prefillHostVars, queueComponentIndexForCheck, refreshDescendantViews} from './instructions';\nimport {ComponentDef, ComponentType} from './interfaces/definition';\nimport {TElementNode, TNodeFlags, TNodeType} from './interfaces/node';\nimport {PlayerHandler} from './interfaces/player';\nimport {RElement, Renderer3, RendererFactory3, domRendererFactory3} from './interfaces/renderer';\nimport {CONTEXT, HEADER_OFFSET, HOST, HOST_NODE, INJECTOR, LViewData, LViewFlags, RootContext, RootContextFlags, TVIEW} from './interfaces/view';\nimport {enterView, leaveView, resetComponentState} from './state';\nimport {defaultScheduler, getRootView, readPatchedLViewData, stringify} from './util';\n\n\n\n/** Options that control how the component should be bootstrapped. */\nexport interface CreateComponentOptions {\n  /** Which renderer factory to use. */\n  rendererFactory?: RendererFactory3;\n\n  /** A custom sanitizer instance */\n  sanitizer?: Sanitizer;\n\n  /** A custom animation player handler */\n  playerHandler?: PlayerHandler;\n\n  /**\n   * Host element on which the component will be bootstrapped. If not specified,\n   * the component definition's `tag` is used to query the existing DOM for the\n   * element to bootstrap.\n   */\n  host?: RElement|string;\n\n  /** Module injector for the component. If unspecified, the injector will be NULL_INJECTOR. */\n  injector?: Injector;\n\n  /**\n   * List of features to be applied to the created component. Features are simply\n   * functions that decorate a component with a certain behavior.\n   *\n   * Typically, the features in this list are features that cannot be added to the\n   * other features list in the component definition because they rely on other factors.\n   *\n   * Example: `RootLifecycleHooks` is a function that adds lifecycle hook capabilities\n   * to root components in a tree-shakable way. It cannot be added to the component\n   * features list because there's no way of knowing when the component will be used as\n   * a root component.\n   */\n  hostFeatures?: HostFeature[];\n\n  /**\n   * A function which is used to schedule change detection work in the future.\n   *\n   * When marking components as dirty, it is necessary to schedule the work of\n   * change detection in the future. This is done to coalesce multiple\n   * {@link markDirty} calls into a single changed detection processing.\n   *\n   * The default value of the scheduler is the `requestAnimationFrame` function.\n   *\n   * It is also useful to override this function for testing purposes.\n   */\n  scheduler?: (work: () => void) => void;\n}\n\n/** See CreateComponentOptions.hostFeatures */\ntype HostFeature = (<T>(component: T, componentDef: ComponentDef<T>) => void);\n\n// TODO: A hack to not pull in the NullInjector from @angular/core.\nexport const NULL_INJECTOR: Injector = {\n  get: (token: any, notFoundValue?: any) => {\n    throw new Error('NullInjector: Not found: ' + stringify(token));\n  }\n};\n\n/**\n * Bootstraps a Component into an existing host element and returns an instance\n * of the component.\n *\n * Use this function to bootstrap a component into the DOM tree. Each invocation\n * of this function will create a separate tree of components, injectors and\n * change detection cycles and lifetimes. To dynamically insert a new component\n * into an existing tree such that it shares the same injection, change detection\n * and object lifetime, use {@link ViewContainer#createComponent}.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\nexport function renderComponent<T>(\n    componentType: ComponentType<T>|\n        Type<T>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */\n    ,\n    opts: CreateComponentOptions = {}): T {\n  ngDevMode && publishDefaultGlobalUtils();\n  ngDevMode && assertComponentType(componentType);\n  const rendererFactory = opts.rendererFactory || domRendererFactory3;\n  const sanitizer = opts.sanitizer || null;\n  const componentDef = getComponentDef<T>(componentType) !;\n  if (componentDef.type != componentType) componentDef.type = componentType;\n\n  // The first index of the first selector is the tag name.\n  const componentTag = componentDef.selectors ![0] ![0] as string;\n  const hostRNode = locateHostElement(rendererFactory, opts.host || componentTag);\n  const rootFlags = componentDef.onPush ? LViewFlags.Dirty | LViewFlags.IsRoot :\n                                          LViewFlags.CheckAlways | LViewFlags.IsRoot;\n  const rootContext = createRootContext(opts.scheduler, opts.playerHandler);\n\n  const renderer = rendererFactory.createRenderer(hostRNode, componentDef);\n  const rootView: LViewData = createLViewData(\n      null, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, rendererFactory,\n      renderer, undefined, opts.injector || null);\n\n  const oldView = enterView(rootView, null);\n  let component: T;\n  try {\n    if (rendererFactory.begin) rendererFactory.begin();\n    const componentView = createRootComponentView(\n        hostRNode, componentDef, rootView, rendererFactory, renderer, sanitizer);\n    component = createRootComponent(\n        componentView, componentDef, rootView, rootContext, opts.hostFeatures || null);\n\n    refreshDescendantViews(rootView, null);\n  } finally {\n    leaveView(oldView);\n    if (rendererFactory.end) rendererFactory.end();\n  }\n\n  return component;\n}\n\n/**\n * Creates the root component view and the root component node.\n *\n * @param rNode Render host element.\n * @param def ComponentDef\n * @param rootView The parent view where the host node is stored\n * @param renderer The current renderer\n * @param sanitizer The sanitizer, if provided\n *\n * @returns Component view created\n */\nexport function createRootComponentView(\n    rNode: RElement | null, def: ComponentDef<any>, rootView: LViewData,\n    rendererFactory: RendererFactory3, renderer: Renderer3,\n    sanitizer?: Sanitizer | null): LViewData {\n  resetComponentState();\n  const tView = rootView[TVIEW];\n  const componentView = createLViewData(\n      rootView,\n      getOrCreateTView(\n          def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery),\n      null, def.onPush ? LViewFlags.Dirty : LViewFlags.CheckAlways, rendererFactory, renderer,\n      sanitizer);\n  const tNode = createNodeAtIndex(0, TNodeType.Element, rNode, null, null);\n\n  if (tView.firstTemplatePass) {\n    diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, rootView), rootView, def.type);\n    tNode.flags = TNodeFlags.isComponent;\n    initNodeFlags(tNode, rootView.length, 1);\n    queueComponentIndexForCheck(tNode);\n  }\n\n  // Store component view at node index, with node as the HOST\n  componentView[HOST] = rootView[HEADER_OFFSET];\n  componentView[HOST_NODE] = tNode as TElementNode;\n  return rootView[HEADER_OFFSET] = componentView;\n}\n\n/**\n * Creates a root component and sets it up with features and host bindings. Shared by\n * renderComponent() and ViewContainerRef.createComponent().\n */\nexport function createRootComponent<T>(\n    componentView: LViewData, componentDef: ComponentDef<T>, rootView: LViewData,\n    rootContext: RootContext, hostFeatures: HostFeature[] | null): any {\n  const tView = rootView[TVIEW];\n  // Create directive instance with factory() and store at next index in viewData\n  const component = instantiateRootComponent(tView, rootView, componentDef);\n\n  rootContext.components.push(component);\n  componentView[CONTEXT] = component;\n\n  hostFeatures && hostFeatures.forEach((feature) => feature(component, componentDef));\n\n  if (tView.firstTemplatePass) prefillHostVars(tView, rootView, componentDef.hostVars);\n  return component;\n}\n\n\nexport function createRootContext(\n    scheduler?: (workFn: () => void) => void, playerHandler?: PlayerHandler|null): RootContext {\n  return {\n    components: [],\n    scheduler: scheduler || defaultScheduler,\n    clean: CLEAN_PROMISE,\n    playerHandler: playerHandler || null,\n    flags: RootContextFlags.Empty\n  };\n}\n\n/**\n * Used to enable lifecycle hooks on the root component.\n *\n * Include this feature when calling `renderComponent` if the root component\n * you are rendering has lifecycle hooks defined. Otherwise, the hooks won't\n * be called properly.\n *\n * Example:\n *\n * ```\n * renderComponent(AppComponent, {features: [RootLifecycleHooks]});\n * ```\n */\nexport function LifecycleHooksFeature(component: any, def: ComponentDef<any>): void {\n  const rootTView = readPatchedLViewData(component) ![TVIEW];\n  const dirIndex = rootTView.data.length - 1;\n\n  queueInitHooks(dirIndex, def.onInit, def.doCheck, rootTView);\n  queueLifecycleHooks(dirIndex << TNodeFlags.DirectiveStartingIndexShift | 1, rootTView);\n}\n\n/**\n * Retrieve the root context for any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootContext(component: any): RootContext {\n  const rootContext = getRootView(component)[CONTEXT] as RootContext;\n  ngDevMode && assertDefined(rootContext, 'rootContext');\n  return rootContext;\n}\n\n\n/**\n * Wait on component until it is rendered.\n *\n * This function returns a `Promise` which is resolved when the component's\n * change detection is executed. This is determined by finding the scheduler\n * associated with the `component`'s render tree and waiting until the scheduler\n * flushes. If nothing is scheduled, the function returns a resolved promise.\n *\n * Example:\n * ```\n * await whenRendered(myComponent);\n * ```\n *\n * @param component Component to wait upon\n * @returns Promise which resolves when the component is rendered.\n */\nexport function whenRendered(component: any): Promise<null> {\n  return getRootContext(component).clean;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"../../","sources":["packages/core/src/render3/component.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\n// We are temporarily importing the existing viewEngine from core so we can be sure we are\n// correctly implementing its interfaces for backwards compatibility.\nimport {Type} from '../core';\nimport {Injector} from '../di/injector';\nimport {Sanitizer} from '../sanitization/security';\n\nimport {assertComponentType, assertDefined} from './assert';\nimport {getComponentDef} from './definition';\nimport {diPublicInInjector, getOrCreateNodeInjectorForNode} from './di';\nimport {publishDefaultGlobalUtils} from './global_utils';\nimport {queueInitHooks, queueLifecycleHooks} from './hooks';\nimport {CLEAN_PROMISE, createLView, createNodeAtIndex, createTNode, createTView, getOrCreateTView, initNodeFlags, instantiateRootComponent, locateHostElement, queueComponentIndexForCheck, refreshDescendantViews} from './instructions';\nimport {ComponentDef, ComponentType, RenderFlags} from './interfaces/definition';\nimport {TElementNode, TNode, TNodeFlags, TNodeType} from './interfaces/node';\nimport {PlayerHandler} from './interfaces/player';\nimport {RElement, Renderer3, RendererFactory3, domRendererFactory3} from './interfaces/renderer';\nimport {CONTEXT, FLAGS, HEADER_OFFSET, HOST, HOST_NODE, LView, LViewFlags, RootContext, RootContextFlags, TVIEW} from './interfaces/view';\nimport {enterView, getPreviousOrParentTNode, leaveView, resetComponentState, setCurrentDirectiveDef} from './state';\nimport {defaultScheduler, getRootView, readPatchedLView, stringify} from './util';\n\n\n\n/** Options that control how the component should be bootstrapped. */\nexport interface CreateComponentOptions {\n  /** Which renderer factory to use. */\n  rendererFactory?: RendererFactory3;\n\n  /** A custom sanitizer instance */\n  sanitizer?: Sanitizer;\n\n  /** A custom animation player handler */\n  playerHandler?: PlayerHandler;\n\n  /**\n   * Host element on which the component will be bootstrapped. If not specified,\n   * the component definition's `tag` is used to query the existing DOM for the\n   * element to bootstrap.\n   */\n  host?: RElement|string;\n\n  /** Module injector for the component. If unspecified, the injector will be NULL_INJECTOR. */\n  injector?: Injector;\n\n  /**\n   * List of features to be applied to the created component. Features are simply\n   * functions that decorate a component with a certain behavior.\n   *\n   * Typically, the features in this list are features that cannot be added to the\n   * other features list in the component definition because they rely on other factors.\n   *\n   * Example: `RootLifecycleHooks` is a function that adds lifecycle hook capabilities\n   * to root components in a tree-shakable way. It cannot be added to the component\n   * features list because there's no way of knowing when the component will be used as\n   * a root component.\n   */\n  hostFeatures?: HostFeature[];\n\n  /**\n   * A function which is used to schedule change detection work in the future.\n   *\n   * When marking components as dirty, it is necessary to schedule the work of\n   * change detection in the future. This is done to coalesce multiple\n   * {@link markDirty} calls into a single changed detection processing.\n   *\n   * The default value of the scheduler is the `requestAnimationFrame` function.\n   *\n   * It is also useful to override this function for testing purposes.\n   */\n  scheduler?: (work: () => void) => void;\n}\n\n/** See CreateComponentOptions.hostFeatures */\ntype HostFeature = (<T>(component: T, componentDef: ComponentDef<T>) => void);\n\n// TODO: A hack to not pull in the NullInjector from @angular/core.\nexport const NULL_INJECTOR: Injector = {\n  get: (token: any, notFoundValue?: any) => {\n    throw new Error('NullInjector: Not found: ' + stringify(token));\n  }\n};\n\n/**\n * Bootstraps a Component into an existing host element and returns an instance\n * of the component.\n *\n * Use this function to bootstrap a component into the DOM tree. Each invocation\n * of this function will create a separate tree of components, injectors and\n * change detection cycles and lifetimes. To dynamically insert a new component\n * into an existing tree such that it shares the same injection, change detection\n * and object lifetime, use {@link ViewContainer#createComponent}.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\nexport function renderComponent<T>(\n    componentType: ComponentType<T>|\n        Type<T>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */\n    ,\n    opts: CreateComponentOptions = {}): T {\n  ngDevMode && publishDefaultGlobalUtils();\n  ngDevMode && assertComponentType(componentType);\n  const rendererFactory = opts.rendererFactory || domRendererFactory3;\n  const sanitizer = opts.sanitizer || null;\n  const componentDef = getComponentDef<T>(componentType) !;\n  if (componentDef.type != componentType) componentDef.type = componentType;\n\n  // The first index of the first selector is the tag name.\n  const componentTag = componentDef.selectors ![0] ![0] as string;\n  const hostRNode = locateHostElement(rendererFactory, opts.host || componentTag);\n  const rootFlags = componentDef.onPush ? LViewFlags.Dirty | LViewFlags.IsRoot :\n                                          LViewFlags.CheckAlways | LViewFlags.IsRoot;\n  const rootContext = createRootContext(opts.scheduler, opts.playerHandler);\n\n  const renderer = rendererFactory.createRenderer(hostRNode, componentDef);\n  const rootView: LView = createLView(\n      null, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, rendererFactory,\n      renderer, undefined, opts.injector || null);\n\n  const oldView = enterView(rootView, null);\n  let component: T;\n  try {\n    if (rendererFactory.begin) rendererFactory.begin();\n    const componentView = createRootComponentView(\n        hostRNode, componentDef, rootView, rendererFactory, renderer, sanitizer);\n    component = createRootComponent(\n        componentView, componentDef, rootView, rootContext, opts.hostFeatures || null);\n\n    refreshDescendantViews(rootView);  // creation mode pass\n    rootView[FLAGS] &= ~LViewFlags.CreationMode;\n    refreshDescendantViews(rootView);  // update mode pass\n  } finally {\n    leaveView(oldView);\n    if (rendererFactory.end) rendererFactory.end();\n  }\n\n  return component;\n}\n\n/**\n * Creates the root component view and the root component node.\n *\n * @param rNode Render host element.\n * @param def ComponentDef\n * @param rootView The parent view where the host node is stored\n * @param renderer The current renderer\n * @param sanitizer The sanitizer, if provided\n *\n * @returns Component view created\n */\nexport function createRootComponentView(\n    rNode: RElement | null, def: ComponentDef<any>, rootView: LView,\n    rendererFactory: RendererFactory3, renderer: Renderer3, sanitizer?: Sanitizer | null): LView {\n  resetComponentState();\n  const tView = rootView[TVIEW];\n  const componentView = createLView(\n      rootView,\n      getOrCreateTView(\n          def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery),\n      null, def.onPush ? LViewFlags.Dirty : LViewFlags.CheckAlways, rendererFactory, renderer,\n      sanitizer);\n  const tNode = createNodeAtIndex(0, TNodeType.Element, rNode, null, null);\n\n  if (tView.firstTemplatePass) {\n    diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, rootView), rootView, def.type);\n    tNode.flags = TNodeFlags.isComponent;\n    initNodeFlags(tNode, rootView.length, 1);\n    queueComponentIndexForCheck(tNode);\n  }\n\n  // Store component view at node index, with node as the HOST\n  componentView[HOST] = rootView[HEADER_OFFSET];\n  componentView[HOST_NODE] = tNode as TElementNode;\n  return rootView[HEADER_OFFSET] = componentView;\n}\n\n/**\n * Creates a root component and sets it up with features and host bindings. Shared by\n * renderComponent() and ViewContainerRef.createComponent().\n */\nexport function createRootComponent<T>(\n    componentView: LView, componentDef: ComponentDef<T>, rootView: LView, rootContext: RootContext,\n    hostFeatures: HostFeature[] | null): any {\n  const tView = rootView[TVIEW];\n  // Create directive instance with factory() and store at next index in viewData\n  const component = instantiateRootComponent(tView, rootView, componentDef);\n\n  rootContext.components.push(component);\n  componentView[CONTEXT] = component;\n\n  hostFeatures && hostFeatures.forEach((feature) => feature(component, componentDef));\n\n  if (tView.firstTemplatePass && componentDef.hostBindings) {\n    const rootTNode = getPreviousOrParentTNode();\n    setCurrentDirectiveDef(componentDef);\n    componentDef.hostBindings(RenderFlags.Create, component, rootTNode.index - HEADER_OFFSET);\n    setCurrentDirectiveDef(null);\n  }\n\n  return component;\n}\n\n\nexport function createRootContext(\n    scheduler?: (workFn: () => void) => void, playerHandler?: PlayerHandler|null): RootContext {\n  return {\n    components: [],\n    scheduler: scheduler || defaultScheduler,\n    clean: CLEAN_PROMISE,\n    playerHandler: playerHandler || null,\n    flags: RootContextFlags.Empty\n  };\n}\n\n/**\n * Used to enable lifecycle hooks on the root component.\n *\n * Include this feature when calling `renderComponent` if the root component\n * you are rendering has lifecycle hooks defined. Otherwise, the hooks won't\n * be called properly.\n *\n * Example:\n *\n * ```\n * renderComponent(AppComponent, {features: [RootLifecycleHooks]});\n * ```\n */\nexport function LifecycleHooksFeature(component: any, def: ComponentDef<any>): void {\n  const rootTView = readPatchedLView(component) ![TVIEW];\n  const dirIndex = rootTView.data.length - 1;\n\n  queueInitHooks(dirIndex, def.onInit, def.doCheck, rootTView);\n  // TODO(misko): replace `as TNode` with createTNode call. (needs refactoring to lose dep on\n  // LNode).\n  queueLifecycleHooks(rootTView, { directiveStart: dirIndex, directiveEnd: dirIndex + 1 } as TNode);\n}\n\n/**\n * Retrieve the root context for any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootContext(component: any): RootContext {\n  const rootContext = getRootView(component)[CONTEXT] as RootContext;\n  ngDevMode && assertDefined(rootContext, 'rootContext');\n  return rootContext;\n}\n\n\n/**\n * Wait on component until it is rendered.\n *\n * This function returns a `Promise` which is resolved when the component's\n * change detection is executed. This is determined by finding the scheduler\n * associated with the `component`'s render tree and waiting until the scheduler\n * flushes. If nothing is scheduled, the function returns a resolved promise.\n *\n * Example:\n * ```\n * await whenRendered(myComponent);\n * ```\n *\n * @param component Component to wait upon\n * @returns Promise which resolves when the component is rendered.\n */\nexport function whenRendered(component: any): Promise<null> {\n  return getRootContext(component).clean;\n}\n"]}