@angular/core 7.2.0-beta.0 → 7.2.0

package/esm2015/src/render3/discovery_utils.js

@@ -1,19 +1,26 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @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 { assertDefined } from './assert';
-import { discoverLocalRefs, getComponentAtNodeIndex, getContext, getDirectivesAtNodeIndex } from './context_discovery';
-import { CONTEXT, FLAGS, HOST, PARENT, TVIEW } from './interfaces/view';
-import { readPatchedLViewData, stringify } from './util';
-import { NodeInjector } from './view_engine_compatibility';
+import { discoverLocalRefs, getComponentAtNodeIndex, getDirectivesAtNodeIndex, getLContext } from './context_discovery';
+import { NodeInjector } from './di';
+import { CLEANUP, CONTEXT, FLAGS, HOST, PARENT, TVIEW } from './interfaces/view';
+import { readElementValue, readPatchedLView, stringify } from './util';
 /**
  * Returns the component instance associated with a given DOM host element.
  * Elements which don't represent components return `null`.
  *
  * \@publicApi
  * @template T
- * @param {?} element Host DOM element from which the component should be retrieved for.
+ * @param {?} element Host DOM element from which the component should be retrieved.
  *
  * ```
  * <my-app>
@@ -30,14 +37,39 @@ import { NodeInjector } from './view_engine_compatibility';
  * @return {?}
  */
 export function getComponent(element) {
-    if (!(element instanceof Node))
-        throw new Error('Expecting instance of DOM Node');
     /** @type {?} */
-    const context = /** @type {?} */ ((loadContext(element)));
+    const context = loadLContextFromNode(element);
     if (context.component === undefined) {
-        context.component = getComponentAtNodeIndex(context.nodeIndex, context.lViewData);
+        context.component = getComponentAtNodeIndex(context.nodeIndex, context.lView);
     }
-    return /** @type {?} */ (context.component);
+    return (/** @type {?} */ (context.component));
+}
+/**
+ * Returns the component instance associated with a given DOM host element.
+ * Elements which don't represent components return `null`.
+ *
+ * \@publicApi
+ * @template T
+ * @param {?} element Host DOM element from which the component should be retrieved.
+ *
+ * ```
+ * <my-app>
+ *   #VIEW
+ *     <div>
+ *       <child-comp></child-comp>
+ *     </div>
+ * </mp-app>
+ *
+ * expect(getComponent(<child-comp>) instanceof ChildComponent).toBeTruthy();
+ * expect(getComponent(<my-app>) instanceof MyApp).toBeTruthy();
+ * ```
+ *
+ * @return {?}
+ */
+export function getContext(element) {
+    /** @type {?} */
+    const context = (/** @type {?} */ (loadLContextFromNode(element)));
+    return (/** @type {?} */ (context.lView[CONTEXT]));
 }
 /**
  * Returns the component instance associated with view which owns the DOM element (`null`
@@ -63,14 +95,14 @@ export function getComponent(element) {
  */
 export function getViewComponent(element) {
     /** @type {?} */
-    const context = /** @type {?} */ ((loadContext(element)));
+    const context = (/** @type {?} */ (loadLContext(element)));
     /** @type {?} */
-    let lView = context.lViewData;
+    let lView = context.lView;
     while (lView[PARENT] && lView[HOST] === null) {
         // As long as lView[HOST] is null we know we are part of sub-template such as `*ngIf`
-        lView = /** @type {?} */ ((lView[PARENT]));
+        lView = (/** @type {?} */ (lView[PARENT]));
     }
-    return lView[FLAGS] & 64 /* IsRoot */ ? null : /** @type {?} */ (lView[CONTEXT]);
+    return lView[FLAGS] & 128 /* IsRoot */ ? null : (/** @type {?} */ (lView[CONTEXT]));
 }
 /**
  * Returns the `RootContext` instance that is associated with
@@ -81,10 +113,10 @@ export function getViewComponent(element) {
  */
 export function getRootContext(target) {
     /** @type {?} */
-    const lViewData = Array.isArray(target) ? target : /** @type {?} */ ((loadContext(target))).lViewData;
+    const lViewData = Array.isArray(target) ? target : (/** @type {?} */ (loadLContext(target))).lView;
     /** @type {?} */
-    const rootLViewData = getRootView(lViewData);
-    return /** @type {?} */ (rootLViewData[CONTEXT]);
+    const rootLView = getRootView(lViewData);
+    return (/** @type {?} */ (rootLView[CONTEXT]));
 }
 /**
  * Retrieve all root components.
@@ -109,10 +141,48 @@ export function getRootComponents(target) {
  */
 export function getInjector(target) {
     /** @type {?} */
-    const context = loadContext(target);
+    const context = loadLContext(target);
+    /** @type {?} */
+    const tNode = (/** @type {?} */ (context.lView[TVIEW].data[context.nodeIndex]));
+    return new NodeInjector(tNode, context.lView);
+}
+/**
+ * Retrieve a set of injection tokens at a given DOM node.
+ *
+ * \@publicApi
+ * @param {?} element Element for which the injection tokens should be retrieved.
+ * @return {?}
+ */
+export function getInjectionTokens(element) {
+    /** @type {?} */
+    const context = loadLContext(element, false);
+    if (!context)
+        return [];
+    /** @type {?} */
+    const lView = context.lView;
+    /** @type {?} */
+    const tView = lView[TVIEW];
+    /** @type {?} */
+    const tNode = (/** @type {?} */ (tView.data[context.nodeIndex]));
+    /** @type {?} */
+    const providerTokens = [];
     /** @type {?} */
-    const tNode = /** @type {?} */ (context.lViewData[TVIEW].data[context.nodeIndex]);
-    return new NodeInjector(tNode, context.lViewData);
+    const startIndex = tNode.providerIndexes & 65535 /* ProvidersStartIndexMask */;
+    /** @type {?} */
+    const endIndex = tNode.directiveEnd;
+    for (let i = startIndex; i < endIndex; i++) {
+        /** @type {?} */
+        let value = tView.data[i];
+        if (isDirectiveDefHack(value)) {
+            // The fact that we sometimes store Type and sometimes DirectiveDef in this location is a
+            // design flaw.  We should always store same type so that we can be monomorphic. The issue
+            // is that for Components/Directives we store the def instead the type. The correct behavior
+            // is that we should always be storing injectable type in this location.
+            value = value.type;
+        }
+        providerTokens.push(value);
+    }
+    return providerTokens;
 }
 /**
  * Retrieves directives associated with a given DOM host element.
@@ -124,9 +194,9 @@ export function getInjector(target) {
  */
 export function getDirectives(target) {
     /** @type {?} */
-    const context = /** @type {?} */ ((loadContext(target)));
+    const context = (/** @type {?} */ (loadLContext(target)));
     if (context.directives === undefined) {
-        context.directives = getDirectivesAtNodeIndex(context.nodeIndex, context.lViewData, false);
+        context.directives = getDirectivesAtNodeIndex(context.nodeIndex, context.lView, false);
     }
     return context.directives || [];
 }
@@ -135,9 +205,9 @@ export function getDirectives(target) {
  * @param {?=} throwOnNotFound
  * @return {?}
  */
-export function loadContext(target, throwOnNotFound = true) {
+export function loadLContext(target, throwOnNotFound = true) {
     /** @type {?} */
-    const context = getContext(target);
+    const context = getLContext(target);
     if (!context && throwOnNotFound) {
         throw new Error(ngDevMode ? `Unable to find context associated with ${stringify(target)}` :
             'Invalid ng target');
@@ -145,8 +215,8 @@ export function loadContext(target, throwOnNotFound = true) {
     return context;
 }
 /**
- * Retrieve the root view from any component by walking the parent `LViewData` until
- * reaching the root `LViewData`.
+ * Retrieve the root view from any component by walking the parent `LView` until
+ * reaching the root `LView`.
  *
  * @param {?} componentOrView any component or view
  *
@@ -154,19 +224,19 @@ export function loadContext(target, throwOnNotFound = true) {
  */
 export function getRootView(componentOrView) {
     /** @type {?} */
-    let lViewData;
+    let lView;
     if (Array.isArray(componentOrView)) {
-        ngDevMode && assertDefined(componentOrView, 'lViewData');
-        lViewData = /** @type {?} */ (componentOrView);
+        ngDevMode && assertDefined(componentOrView, 'lView');
+        lView = (/** @type {?} */ (componentOrView));
     }
     else {
         ngDevMode && assertDefined(componentOrView, 'component');
-        lViewData = /** @type {?} */ ((readPatchedLViewData(componentOrView)));
+        lView = (/** @type {?} */ (readPatchedLView(componentOrView)));
     }
-    while (lViewData && !(lViewData[FLAGS] & 64 /* IsRoot */)) {
-        lViewData = /** @type {?} */ ((lViewData[PARENT]));
+    while (lView && !(lView[FLAGS] & 128 /* IsRoot */)) {
+        lView = (/** @type {?} */ (lView[PARENT]));
     }
-    return lViewData;
+    return lView;
 }
 /**
  * Retrieve map of local references.
@@ -180,9 +250,9 @@ export function getRootView(componentOrView) {
  */
 export function getLocalRefs(target) {
     /** @type {?} */
-    const context = /** @type {?} */ ((loadContext(target)));
+    const context = (/** @type {?} */ (loadLContext(target)));
     if (context.localRefs === undefined) {
-        context.localRefs = discoverLocalRefs(context.lViewData, context.nodeIndex);
+        context.localRefs = discoverLocalRefs(context.lView, context.nodeIndex);
     }
     return context.localRefs || {};
 }
@@ -199,7 +269,7 @@ export function getLocalRefs(target) {
  * @return {?}
  */
 export function getHostElement(directive) {
-    return /** @type {?} */ ((((getContext(directive))).native));
+    return (/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (getLContext(directive))).native))));
 }
 /**
  * Retrieves the rendered text for a given component.
@@ -217,5 +287,121 @@ export function getRenderedText(component) {
     const hostElement = getHostElement(component);
     return hostElement.textContent || '';
 }
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery_utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/discovery_utils.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 */\nimport {Injector} from '../di/injector';\n\nimport {assertDefined} from './assert';\nimport {discoverLocalRefs, getComponentAtNodeIndex, getContext, getDirectivesAtNodeIndex} from './context_discovery';\nimport {LContext} from './interfaces/context';\nimport {TElementNode} from './interfaces/node';\nimport {CONTEXT, FLAGS, HOST, LViewData, LViewFlags, PARENT, RootContext, TVIEW} from './interfaces/view';\nimport {readPatchedLViewData, stringify} from './util';\nimport {NodeInjector} from './view_engine_compatibility';\n\n\n/**\n * Returns the component instance associated with a given DOM host element.\n * Elements which don't represent components return `null`.\n *\n * @param element Host DOM element from which the component should be retrieved for.\n *\n * ```\n * <my-app>\n *   #VIEW\n *     <div>\n *       <child-comp></child-comp>\n *     </div>\n * </mp-app>\n *\n * expect(getComponent(<child-comp>) instanceof ChildComponent).toBeTruthy();\n * expect(getComponent(<my-app>) instanceof MyApp).toBeTruthy();\n * ```\n *\n * @publicApi\n */\nexport function getComponent<T = {}>(element: Element): T|null {\n  if (!(element instanceof Node)) throw new Error('Expecting instance of DOM Node');\n\n  const context = loadContext(element) !;\n\n  if (context.component === undefined) {\n    context.component = getComponentAtNodeIndex(context.nodeIndex, context.lViewData);\n  }\n\n  return context.component as T;\n}\n\n/**\n * Returns the component instance associated with view which owns the DOM element (`null`\n * otherwise).\n *\n * @param element DOM element which is owned by an existing component's view.\n *\n * ```\n * <my-app>\n *   #VIEW\n *     <div>\n *       <child-comp></child-comp>\n *     </div>\n * </mp-app>\n *\n * expect(getViewComponent(<child-comp>) instanceof MyApp).toBeTruthy();\n * expect(getViewComponent(<my-app>)).toEqual(null);\n * ```\n *\n * @publicApi\n */\nexport function getViewComponent<T = {}>(element: Element | {}): T|null {\n  const context = loadContext(element) !;\n  let lView: LViewData = context.lViewData;\n  while (lView[PARENT] && lView[HOST] === null) {\n    // As long as lView[HOST] is null we know we are part of sub-template such as `*ngIf`\n    lView = lView[PARENT] !;\n  }\n\n  return lView[FLAGS] & LViewFlags.IsRoot ? null : lView[CONTEXT] as T;\n}\n\n\n\n/**\n * Returns the `RootContext` instance that is associated with\n * the application where the target is situated.\n *\n */\nexport function getRootContext(target: LViewData | {}): RootContext {\n  const lViewData = Array.isArray(target) ? target : loadContext(target) !.lViewData;\n  const rootLViewData = getRootView(lViewData);\n  return rootLViewData[CONTEXT] as RootContext;\n}\n\n/**\n * Retrieve all root components.\n *\n * Root components are those which have been bootstrapped by Angular.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getRootComponents(target: {}): any[] {\n  return [...getRootContext(target).components];\n}\n\n/**\n * Retrieves an `Injector` associated with the element, component or directive.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getInjector(target: {}): Injector {\n  const context = loadContext(target);\n  const tNode = context.lViewData[TVIEW].data[context.nodeIndex] as TElementNode;\n\n  return new NodeInjector(tNode, context.lViewData);\n}\n\n/**\n * Retrieves directives associated with a given DOM host element.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getDirectives(target: {}): Array<{}> {\n  const context = loadContext(target) !;\n\n  if (context.directives === undefined) {\n    context.directives = getDirectivesAtNodeIndex(context.nodeIndex, context.lViewData, false);\n  }\n\n  return context.directives || [];\n}\n\n/**\n * Returns LContext associated with a target passed as an argument.\n * Throws if a given target doesn't have associated LContext.\n *\n */\nexport function loadContext(target: {}): LContext;\nexport function loadContext(target: {}, throwOnNotFound: false): LContext|null;\nexport function loadContext(target: {}, throwOnNotFound: boolean = true): LContext|null {\n  const context = getContext(target);\n  if (!context && throwOnNotFound) {\n    throw new Error(\n        ngDevMode ? `Unable to find context associated with ${stringify(target)}` :\n                    'Invalid ng target');\n  }\n  return context;\n}\n\n/**\n * Retrieve the root view from any component by walking the parent `LViewData` until\n * reaching the root `LViewData`.\n *\n * @param componentOrView any component or view\n *\n */\nexport function getRootView(componentOrView: LViewData | {}): LViewData {\n  let lViewData: LViewData;\n  if (Array.isArray(componentOrView)) {\n    ngDevMode && assertDefined(componentOrView, 'lViewData');\n    lViewData = componentOrView as LViewData;\n  } else {\n    ngDevMode && assertDefined(componentOrView, 'component');\n    lViewData = readPatchedLViewData(componentOrView) !;\n  }\n  while (lViewData && !(lViewData[FLAGS] & LViewFlags.IsRoot)) {\n    lViewData = lViewData[PARENT] !;\n  }\n  return lViewData;\n}\n\n/**\n * Retrieve map of local references.\n *\n * The references are retrieved as a map of local reference name to element or directive instance.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getLocalRefs(target: {}): {[key: string]: any} {\n  const context = loadContext(target) !;\n\n  if (context.localRefs === undefined) {\n    context.localRefs = discoverLocalRefs(context.lViewData, context.nodeIndex);\n  }\n\n  return context.localRefs || {};\n}\n\n/**\n * Retrieve the host element of the component.\n *\n * Use this function to retrieve the host element of the component. The host\n * element is the element which the component is associated with.\n *\n * @param directive Component or Directive for which the host element should be retrieved.\n *\n * @publicApi\n */\nexport function getHostElement<T>(directive: T): Element {\n  return getContext(directive) !.native as never as Element;\n}\n\n/**\n * Retrieves the rendered text for a given component.\n *\n * This function retrieves the host element of a component and\n * and then returns the `textContent` for that element. This implies\n * that the text returned will include re-projected content of\n * the component as well.\n *\n * @param component The component to return the content text for.\n */\nexport function getRenderedText(component: any): string {\n  const hostElement = getHostElement(component);\n  return hostElement.textContent || '';\n}"]}
+/**
+ * @param {?} node
+ * @return {?}
+ */
+export function loadLContextFromNode(node) {
+    if (!(node instanceof Node))
+        throw new Error('Expecting instance of DOM Node');
+    return (/** @type {?} */ (loadLContext(node)));
+}
+/**
+ * @record
+ */
+export function Listener() { }
+if (false) {
+    /** @type {?} */
+    Listener.prototype.name;
+    /** @type {?} */
+    Listener.prototype.element;
+    /** @type {?} */
+    Listener.prototype.callback;
+    /** @type {?} */
+    Listener.prototype.useCapture;
+}
+/**
+ * @param {?} listener
+ * @return {?}
+ */
+export function isBrowserEvents(listener) {
+    // Browser events are those which don't have `useCapture` as boolean.
+    return typeof listener.useCapture === 'boolean';
+}
+/**
+ * Retrieves a list of DOM listeners.
+ *
+ * ```
+ * <my-app>
+ *   #VIEW
+ *     <div (click)="doSomething()">
+ *     </div>
+ * </mp-app>
+ *
+ * expect(getListeners(<div>)).toEqual({
+ *   name: 'click',
+ *   element: <div>,
+ *   callback: () => doSomething(),
+ *   useCapture: false
+ * });
+ * ```
+ *
+ * \@publicApi
+ * @param {?} element Element for which the DOM listeners should be retrieved.
+ * @return {?}
+ */
+export function getListeners(element) {
+    /** @type {?} */
+    const lContext = loadLContextFromNode(element);
+    /** @type {?} */
+    const lView = lContext.lView;
+    /** @type {?} */
+    const tView = lView[TVIEW];
+    /** @type {?} */
+    const lCleanup = lView[CLEANUP];
+    /** @type {?} */
+    const tCleanup = tView.cleanup;
+    /** @type {?} */
+    const listeners = [];
+    if (tCleanup && lCleanup) {
+        for (let i = 0; i < tCleanup.length;) {
+            /** @type {?} */
+            const firstParam = tCleanup[i++];
+            /** @type {?} */
+            const secondParam = tCleanup[i++];
+            if (typeof firstParam === 'string') {
+                /** @type {?} */
+                const name = firstParam;
+                /** @type {?} */
+                const listenerElement = (/** @type {?} */ ((/** @type {?} */ (readElementValue(lView[secondParam])))));
+                /** @type {?} */
+                const callback = lCleanup[tCleanup[i++]];
+                /** @type {?} */
+                const useCaptureOrIndx = tCleanup[i++];
+                // if useCaptureOrIndx is boolean then report it as is.
+                // if useCaptureOrIndx is positive number then it in unsubscribe method
+                // if useCaptureOrIndx is negative number then it is a Subscription
+                /** @type {?} */
+                const useCapture = typeof useCaptureOrIndx === 'boolean' ?
+                    useCaptureOrIndx :
+                    (useCaptureOrIndx >= 0 ? false : null);
+                if (element == listenerElement) {
+                    listeners.push({ element, name, callback, useCapture });
+                }
+            }
+        }
+    }
+    listeners.sort(sortListeners);
+    return listeners;
+}
+/**
+ * @param {?} a
+ * @param {?} b
+ * @return {?}
+ */
+function sortListeners(a, b) {
+    if (a.name == b.name)
+        return 0;
+    return a.name < b.name ? -1 : 1;
+}
+/**
+ * This function should not exist because it is megamorphic and only mostly correct.
+ *
+ * See call site for more info.
+ * @param {?} obj
+ * @return {?}
+ */
+function isDirectiveDefHack(obj) {
+    return obj.type !== undefined && obj.template !== undefined && obj.declaredInputs !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery_utils.js","sourceRoot":"../../","sources":["packages/core/src/render3/discovery_utils.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 {Injector} from '../di/injector';\n\nimport {assertDefined} from './assert';\nimport {discoverLocalRefs, getComponentAtNodeIndex, getDirectivesAtNodeIndex, getLContext} from './context_discovery';\nimport {NodeInjector} from './di';\nimport {LContext} from './interfaces/context';\nimport {DirectiveDef} from './interfaces/definition';\nimport {TElementNode, TNode, TNodeProviderIndexes} from './interfaces/node';\nimport {CLEANUP, CONTEXT, FLAGS, HOST, LView, LViewFlags, PARENT, RootContext, TVIEW} from './interfaces/view';\nimport {readElementValue, readPatchedLView, stringify} from './util';\n\n\n\n/**\n * Returns the component instance associated with a given DOM host element.\n * Elements which don't represent components return `null`.\n *\n * @param element Host DOM element from which the component should be retrieved.\n *\n * ```\n * <my-app>\n *   #VIEW\n *     <div>\n *       <child-comp></child-comp>\n *     </div>\n * </mp-app>\n *\n * expect(getComponent(<child-comp>) instanceof ChildComponent).toBeTruthy();\n * expect(getComponent(<my-app>) instanceof MyApp).toBeTruthy();\n * ```\n *\n * @publicApi\n */\nexport function getComponent<T = {}>(element: Element): T|null {\n  const context = loadLContextFromNode(element);\n\n  if (context.component === undefined) {\n    context.component = getComponentAtNodeIndex(context.nodeIndex, context.lView);\n  }\n\n  return context.component as T;\n}\n\n/**\n * Returns the component instance associated with a given DOM host element.\n * Elements which don't represent components return `null`.\n *\n * @param element Host DOM element from which the component should be retrieved.\n *\n * ```\n * <my-app>\n *   #VIEW\n *     <div>\n *       <child-comp></child-comp>\n *     </div>\n * </mp-app>\n *\n * expect(getComponent(<child-comp>) instanceof ChildComponent).toBeTruthy();\n * expect(getComponent(<my-app>) instanceof MyApp).toBeTruthy();\n * ```\n *\n * @publicApi\n */\nexport function getContext<T = {}>(element: Element): T|null {\n  const context = loadLContextFromNode(element) !;\n  return context.lView[CONTEXT] as T;\n}\n\n/**\n * Returns the component instance associated with view which owns the DOM element (`null`\n * otherwise).\n *\n * @param element DOM element which is owned by an existing component's view.\n *\n * ```\n * <my-app>\n *   #VIEW\n *     <div>\n *       <child-comp></child-comp>\n *     </div>\n * </mp-app>\n *\n * expect(getViewComponent(<child-comp>) instanceof MyApp).toBeTruthy();\n * expect(getViewComponent(<my-app>)).toEqual(null);\n * ```\n *\n * @publicApi\n */\nexport function getViewComponent<T = {}>(element: Element | {}): T|null {\n  const context = loadLContext(element) !;\n  let lView: LView = context.lView;\n  while (lView[PARENT] && lView[HOST] === null) {\n    // As long as lView[HOST] is null we know we are part of sub-template such as `*ngIf`\n    lView = lView[PARENT] !;\n  }\n\n  return lView[FLAGS] & LViewFlags.IsRoot ? null : lView[CONTEXT] as T;\n}\n\n\n\n/**\n * Returns the `RootContext` instance that is associated with\n * the application where the target is situated.\n *\n */\nexport function getRootContext(target: LView | {}): RootContext {\n  const lViewData = Array.isArray(target) ? target : loadLContext(target) !.lView;\n  const rootLView = getRootView(lViewData);\n  return rootLView[CONTEXT] as RootContext;\n}\n\n/**\n * Retrieve all root components.\n *\n * Root components are those which have been bootstrapped by Angular.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getRootComponents(target: {}): any[] {\n  return [...getRootContext(target).components];\n}\n\n/**\n * Retrieves an `Injector` associated with the element, component or directive.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getInjector(target: {}): Injector {\n  const context = loadLContext(target);\n  const tNode = context.lView[TVIEW].data[context.nodeIndex] as TElementNode;\n  return new NodeInjector(tNode, context.lView);\n}\n\n/**\n * Retrieve a set of injection tokens at a given DOM node.\n *\n * @param element Element for which the injection tokens should be retrieved.\n * @publicApi\n */\nexport function getInjectionTokens(element: Element): any[] {\n  const context = loadLContext(element, false);\n  if (!context) return [];\n  const lView = context.lView;\n  const tView = lView[TVIEW];\n  const tNode = tView.data[context.nodeIndex] as TNode;\n  const providerTokens: any[] = [];\n  const startIndex = tNode.providerIndexes & TNodeProviderIndexes.ProvidersStartIndexMask;\n  const endIndex = tNode.directiveEnd;\n  for (let i = startIndex; i < endIndex; i++) {\n    let value = tView.data[i];\n    if (isDirectiveDefHack(value)) {\n      // The fact that we sometimes store Type and sometimes DirectiveDef in this location is a\n      // design flaw.  We should always store same type so that we can be monomorphic. The issue\n      // is that for Components/Directives we store the def instead the type. The correct behavior\n      // is that we should always be storing injectable type in this location.\n      value = value.type;\n    }\n    providerTokens.push(value);\n  }\n  return providerTokens;\n}\n\n/**\n * Retrieves directives associated with a given DOM host element.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getDirectives(target: {}): Array<{}> {\n  const context = loadLContext(target) !;\n\n  if (context.directives === undefined) {\n    context.directives = getDirectivesAtNodeIndex(context.nodeIndex, context.lView, false);\n  }\n\n  return context.directives || [];\n}\n\n/**\n * Returns LContext associated with a target passed as an argument.\n * Throws if a given target doesn't have associated LContext.\n *\n */\nexport function loadLContext(target: {}): LContext;\nexport function loadLContext(target: {}, throwOnNotFound: false): LContext|null;\nexport function loadLContext(target: {}, throwOnNotFound: boolean = true): LContext|null {\n  const context = getLContext(target);\n  if (!context && throwOnNotFound) {\n    throw new Error(\n        ngDevMode ? `Unable to find context associated with ${stringify(target)}` :\n                    'Invalid ng target');\n  }\n  return context;\n}\n\n/**\n * Retrieve the root view from any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param componentOrView any component or view\n *\n */\nexport function getRootView(componentOrView: LView | {}): LView {\n  let lView: LView;\n  if (Array.isArray(componentOrView)) {\n    ngDevMode && assertDefined(componentOrView, 'lView');\n    lView = componentOrView as LView;\n  } else {\n    ngDevMode && assertDefined(componentOrView, 'component');\n    lView = readPatchedLView(componentOrView) !;\n  }\n  while (lView && !(lView[FLAGS] & LViewFlags.IsRoot)) {\n    lView = lView[PARENT] !;\n  }\n  return lView;\n}\n\n/**\n * Retrieve map of local references.\n *\n * The references are retrieved as a map of local reference name to element or directive instance.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nexport function getLocalRefs(target: {}): {[key: string]: any} {\n  const context = loadLContext(target) !;\n\n  if (context.localRefs === undefined) {\n    context.localRefs = discoverLocalRefs(context.lView, context.nodeIndex);\n  }\n\n  return context.localRefs || {};\n}\n\n/**\n * Retrieve the host element of the component.\n *\n * Use this function to retrieve the host element of the component. The host\n * element is the element which the component is associated with.\n *\n * @param directive Component or Directive for which the host element should be retrieved.\n *\n * @publicApi\n */\nexport function getHostElement<T>(directive: T): Element {\n  return getLContext(directive) !.native as never as Element;\n}\n\n/**\n * Retrieves the rendered text for a given component.\n *\n * This function retrieves the host element of a component and\n * and then returns the `textContent` for that element. This implies\n * that the text returned will include re-projected content of\n * the component as well.\n *\n * @param component The component to return the content text for.\n */\nexport function getRenderedText(component: any): string {\n  const hostElement = getHostElement(component);\n  return hostElement.textContent || '';\n}\n\nexport function loadLContextFromNode(node: Node): LContext {\n  if (!(node instanceof Node)) throw new Error('Expecting instance of DOM Node');\n  return loadLContext(node) !;\n}\n\nexport interface Listener {\n  name: string;\n  element: Element;\n  callback: (value: any) => any;\n  useCapture: boolean|null;\n}\n\nexport function isBrowserEvents(listener: Listener): boolean {\n  // Browser events are those which don't have `useCapture` as boolean.\n  return typeof listener.useCapture === 'boolean';\n}\n\n\n/**\n * Retrieves a list of DOM listeners.\n *\n * ```\n * <my-app>\n *   #VIEW\n *     <div (click)=\"doSomething()\">\n *     </div>\n * </mp-app>\n *\n * expect(getListeners(<div>)).toEqual({\n *   name: 'click',\n *   element: <div>,\n *   callback: () => doSomething(),\n *   useCapture: false\n * });\n * ```\n *\n * @param element Element for which the DOM listeners should be retrieved.\n * @publicApi\n */\nexport function getListeners(element: Element): Listener[] {\n  const lContext = loadLContextFromNode(element);\n  const lView = lContext.lView;\n  const tView = lView[TVIEW];\n  const lCleanup = lView[CLEANUP];\n  const tCleanup = tView.cleanup;\n  const listeners: Listener[] = [];\n  if (tCleanup && lCleanup) {\n    for (let i = 0; i < tCleanup.length;) {\n      const firstParam = tCleanup[i++];\n      const secondParam = tCleanup[i++];\n      if (typeof firstParam === 'string') {\n        const name: string = firstParam;\n        const listenerElement = readElementValue(lView[secondParam]) as any as Element;\n        const callback: (value: any) => any = lCleanup[tCleanup[i++]];\n        const useCaptureOrIndx = tCleanup[i++];\n        // if useCaptureOrIndx is boolean then report it as is.\n        // if useCaptureOrIndx is positive number then it in unsubscribe method\n        // if useCaptureOrIndx is negative number then it is a Subscription\n        const useCapture = typeof useCaptureOrIndx === 'boolean' ?\n            useCaptureOrIndx :\n            (useCaptureOrIndx >= 0 ? false : null);\n        if (element == listenerElement) {\n          listeners.push({element, name, callback, useCapture});\n        }\n      }\n    }\n  }\n  listeners.sort(sortListeners);\n  return listeners;\n}\n\nfunction sortListeners(a: Listener, b: Listener) {\n  if (a.name == b.name) return 0;\n  return a.name < b.name ? -1 : 1;\n}\n\n/**\n * This function should not exist because it is megamorphic and only mostly correct.\n *\n * See call site for more info.\n */\nfunction isDirectiveDefHack(obj: any): obj is DirectiveDef<any> {\n  return obj.type !== undefined && obj.template !== undefined && obj.declaredInputs !== undefined;\n}\n"]}

package/esm2015/src/render3/empty.js

@@ -0,0 +1,28 @@
+/**
+ * @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 './ng_dev_mode';
+/**
+ * This file contains reuseable "empty" symbols that can be used as default return values
+ * in different parts of the rendering code. Because the same symbols are returned, this
+ * allows for identity checks against these values to be consistently used by the framework
+ * code.
+ * @type {?}
+ */
+export const EMPTY_OBJ = {};
+/** @type {?} */
+export const EMPTY_ARRAY = [];
+// freezing the values prevents any code from accidentally inserting new values in
+if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+    Object.freeze(EMPTY_OBJ);
+    Object.freeze(EMPTY_ARRAY);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHkuanMiLCJzb3VyY2VSb290IjoiLi4vLi4vIiwic291cmNlcyI6WyJwYWNrYWdlcy9jb3JlL3NyYy9yZW5kZXIzL2VtcHR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBT0EsT0FBTyxlQUFlLENBQUM7Ozs7Ozs7O0FBU3ZCLE1BQU0sT0FBTyxTQUFTLEdBQU8sRUFBRTs7QUFDL0IsTUFBTSxPQUFPLFdBQVcsR0FBVSxFQUFFOztBQUdwQyxJQUFJLE9BQU8sU0FBUyxLQUFLLFdBQVcsSUFBSSxTQUFTLEVBQUU7SUFDakQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUN6QixNQUFNLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0NBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4qIEBsaWNlbnNlXG4qIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuKlxuKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4qL1xuaW1wb3J0ICcuL25nX2Rldl9tb2RlJztcblxuLyoqXG4gKiBUaGlzIGZpbGUgY29udGFpbnMgcmV1c2VhYmxlIFwiZW1wdHlcIiBzeW1ib2xzIHRoYXQgY2FuIGJlIHVzZWQgYXMgZGVmYXVsdCByZXR1cm4gdmFsdWVzXG4gKiBpbiBkaWZmZXJlbnQgcGFydHMgb2YgdGhlIHJlbmRlcmluZyBjb2RlLiBCZWNhdXNlIHRoZSBzYW1lIHN5bWJvbHMgYXJlIHJldHVybmVkLCB0aGlzXG4gKiBhbGxvd3MgZm9yIGlkZW50aXR5IGNoZWNrcyBhZ2FpbnN0IHRoZXNlIHZhbHVlcyB0byBiZSBjb25zaXN0ZW50bHkgdXNlZCBieSB0aGUgZnJhbWV3b3JrXG4gKiBjb2RlLlxuICovXG5cbmV4cG9ydCBjb25zdCBFTVBUWV9PQko6IHt9ID0ge307XG5leHBvcnQgY29uc3QgRU1QVFlfQVJSQVk6IGFueVtdID0gW107XG5cbi8vIGZyZWV6aW5nIHRoZSB2YWx1ZXMgcHJldmVudHMgYW55IGNvZGUgZnJvbSBhY2NpZGVudGFsbHkgaW5zZXJ0aW5nIG5ldyB2YWx1ZXMgaW5cbmlmICh0eXBlb2YgbmdEZXZNb2RlICE9PSAndW5kZWZpbmVkJyAmJiBuZ0Rldk1vZGUpIHtcbiAgT2JqZWN0LmZyZWV6ZShFTVBUWV9PQkopO1xuICBPYmplY3QuZnJlZXplKEVNUFRZX0FSUkFZKTtcbn1cbiJdfQ==

package/esm2015/src/render3/errors.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
  */
 /**
  * Called when directives inject each other (creating a circular dependency)
@@ -21,23 +21,19 @@ export function throwMultipleComponentError(tNode) {
 /**
  * Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on.
  * @param {?} creationMode
- * @param {?} checkNoChangesMode
  * @param {?} oldValue
  * @param {?} currValue
  * @return {?}
  */
-export function throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, oldValue, currValue) {
-    if (checkNoChangesMode) {
-        /** @type {?} */
-        let msg = `ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;
-        if (creationMode) {
-            msg +=
-                ` It seems like the view has been created after its parent and its children have been dirty checked.` +
-                    ` Has it been created in a change detection hook ?`;
-        }
-        // TODO: include debug context
-        throw new Error(msg);
+export function throwErrorIfNoChangesMode(creationMode, oldValue, currValue) {
+    /** @type {?} */
+    let msg = `ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;
+    if (creationMode) {
+        msg +=
+            ` It seems like the view has been created after its parent and its children have been dirty checked.` +
+                ` Has it been created in a change detection hook ?`;
     }
+    // TODO: include debug context
+    throw new Error(msg);
 }
-
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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