@angular/core 7.0.0-rc.1 → 7.0.3

package/esm5/src/render3/styling/core_player_handler.js

@@ -5,7 +5,7 @@ var CorePlayerHandler = /** @class */ (function () {
     CorePlayerHandler.prototype.flushPlayers = function () {
         for (var i = 0; i < this._players.length; i++) {
             var player = this._players[i];
-            if (!player.parent) {
+            if (!player.parent && player.state === 0 /* Pending */) {
                 player.play();
             }
         }
@@ -16,4 +16,4 @@ var CorePlayerHandler = /** @class */ (function () {
 }());
 export { CorePlayerHandler };
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZV9wbGF5ZXJfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvc3R5bGluZy9jb3JlX3BsYXllcl9oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBO0lBQUE7UUFDVSxhQUFRLEdBQWEsRUFBRSxDQUFDO0lBYWxDLENBQUM7SUFYQyx3Q0FBWSxHQUFaO1FBQ0UsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1lBQzdDLElBQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDaEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUU7Z0JBQ2xCLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQzthQUNmO1NBQ0Y7UUFDRCxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELHVDQUFXLEdBQVgsVUFBWSxNQUFjLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzdELHdCQUFDO0FBQUQsQ0FBQyxBQWRELElBY0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge1BsYXllciwgUGxheWVySGFuZGxlcn0gZnJvbSAnLi4vaW50ZXJmYWNlcy9wbGF5ZXInO1xuXG5leHBvcnQgY2xhc3MgQ29yZVBsYXllckhhbmRsZXIgaW1wbGVtZW50cyBQbGF5ZXJIYW5kbGVyIHtcbiAgcHJpdmF0ZSBfcGxheWVyczogUGxheWVyW10gPSBbXTtcblxuICBmbHVzaFBsYXllcnMoKSB7XG4gICAgZm9yIChsZXQgaSA9IDA7IGkgPCB0aGlzLl9wbGF5ZXJzLmxlbmd0aDsgaSsrKSB7XG4gICAgICBjb25zdCBwbGF5ZXIgPSB0aGlzLl9wbGF5ZXJzW2ldO1xuICAgICAgaWYgKCFwbGF5ZXIucGFyZW50KSB7XG4gICAgICAgIHBsYXllci5wbGF5KCk7XG4gICAgICB9XG4gICAgfVxuICAgIHRoaXMuX3BsYXllcnMubGVuZ3RoID0gMDtcbiAgfVxuXG4gIHF1ZXVlUGxheWVyKHBsYXllcjogUGxheWVyKSB7IHRoaXMuX3BsYXllcnMucHVzaChwbGF5ZXIpOyB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZV9wbGF5ZXJfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvc3R5bGluZy9jb3JlX3BsYXllcl9oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBO0lBQUE7UUFDVSxhQUFRLEdBQWEsRUFBRSxDQUFDO0lBYWxDLENBQUM7SUFYQyx3Q0FBWSxHQUFaO1FBQ0UsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1lBQzdDLElBQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDaEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLEtBQUssb0JBQXNCLEVBQUU7Z0JBQ3hELE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQzthQUNmO1NBQ0Y7UUFDRCxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELHVDQUFXLEdBQVgsVUFBWSxNQUFjLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzdELHdCQUFDO0FBQUQsQ0FBQyxBQWRELElBY0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge1BsYXlTdGF0ZSwgUGxheWVyLCBQbGF5ZXJIYW5kbGVyfSBmcm9tICcuLi9pbnRlcmZhY2VzL3BsYXllcic7XG5cbmV4cG9ydCBjbGFzcyBDb3JlUGxheWVySGFuZGxlciBpbXBsZW1lbnRzIFBsYXllckhhbmRsZXIge1xuICBwcml2YXRlIF9wbGF5ZXJzOiBQbGF5ZXJbXSA9IFtdO1xuXG4gIGZsdXNoUGxheWVycygpIHtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHRoaXMuX3BsYXllcnMubGVuZ3RoOyBpKyspIHtcbiAgICAgIGNvbnN0IHBsYXllciA9IHRoaXMuX3BsYXllcnNbaV07XG4gICAgICBpZiAoIXBsYXllci5wYXJlbnQgJiYgcGxheWVyLnN0YXRlID09PSBQbGF5U3RhdGUuUGVuZGluZykge1xuICAgICAgICBwbGF5ZXIucGxheSgpO1xuICAgICAgfVxuICAgIH1cbiAgICB0aGlzLl9wbGF5ZXJzLmxlbmd0aCA9IDA7XG4gIH1cblxuICBxdWV1ZVBsYXllcihwbGF5ZXI6IFBsYXllcikgeyB0aGlzLl9wbGF5ZXJzLnB1c2gocGxheWVyKTsgfVxufVxuIl19

package/esm5/src/render3/styling/player_factory.js

@@ -0,0 +1,29 @@
+/**
+ * Combines the binding value and a factory for an animation player.
+ *
+ * Used to bind a player to an element template binding (currently only
+ * `[style]`, `[style.prop]`, `[class]` and `[class.name]` bindings
+ * supported). The provided `factoryFn` function will be run once all
+ * the associated bindings have been evaluated on the element and is
+ * designed to return a player which will then be placed on the element.
+ *
+ * @param factoryFn The function that is used to create a player
+ *   once all the rendering-related (styling values) have been
+ *   processed for the element binding.
+ * @param value The raw value that will be exposed to the binding
+ *   so that the binding can update its internal values when
+ *   any changes are evaluated.
+ */
+export function bindPlayerFactory(factoryFn, value) {
+    return new BoundPlayerFactory(factoryFn, value);
+}
+var BoundPlayerFactory = /** @class */ (function () {
+    function BoundPlayerFactory(fn, value) {
+        this.fn = fn;
+        this.value = value;
+    }
+    return BoundPlayerFactory;
+}());
+export { BoundPlayerFactory };
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/src/render3/styling/util.js

@@ -1,26 +1,144 @@
+/**
+ * @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';
 import { getContext } from '../context_discovery';
-export var EMPTY_ARR = [];
-export var EMPTY_OBJ = {};
+import { ACTIVE_INDEX } from '../interfaces/container';
+import { FLAGS, HEADER_OFFSET, HOST } from '../interfaces/view';
+import { getTNode } from '../util';
+import { CorePlayerHandler } from './core_player_handler';
 export function createEmptyStylingContext(element, sanitizer, initialStylingValues) {
     return [
-        element || null, null, sanitizer || null, initialStylingValues || [null], 0, 0, null, null
+        null,
+        sanitizer || null,
+        initialStylingValues || [null],
+        0,
+        0,
+        element || null,
+        null,
+        null // PreviousMultiStyleValue
     ];
 }
+/**
+ * Used clone a copy of a pre-computed template of a styling context.
+ *
+ * A pre-computed template is designed to be computed once for a given element
+ * (instructions.ts has logic for caching this).
+ */
+export function allocStylingContext(element, templateStyleContext) {
+    // each instance gets a copy
+    var context = templateStyleContext.slice();
+    context[5 /* ElementPosition */] = element;
+    return context;
+}
+/**
+ * Retrieve the `StylingContext` at a given index.
+ *
+ * This method lazily creates the `StylingContext`. This is because in most cases
+ * we have styling without any bindings. Creating `StylingContext` eagerly would mean that
+ * every style declaration such as `<div style="color: red">` would result `StyleContext`
+ * which would create unnecessary memory pressure.
+ *
+ * @param index Index of the style allocation. See: `elementStyling`.
+ * @param viewData The view to search for the styling context
+ */
+export function getStylingContext(index, viewData) {
+    var storageIndex = index + HEADER_OFFSET;
+    var slotValue = viewData[storageIndex];
+    var wrapper = viewData;
+    while (Array.isArray(slotValue)) {
+        wrapper = slotValue;
+        slotValue = slotValue[HOST];
+    }
+    if (isStylingContext(wrapper)) {
+        return wrapper;
+    }
+    else {
+        // This is an LViewData or an LContainer
+        var stylingTemplate = getTNode(index, viewData).stylingTemplate;
+        if (wrapper !== viewData) {
+            storageIndex = HOST;
+        }
+        return wrapper[storageIndex] = stylingTemplate ?
+            allocStylingContext(slotValue, stylingTemplate) :
+            createEmptyStylingContext(slotValue);
+    }
+}
+function isStylingContext(value) {
+    // Not an LViewData or an LContainer
+    return typeof value[FLAGS] !== 'number' && typeof value[ACTIVE_INDEX] !== 'number';
+}
+export function addPlayerInternal(playerContext, rootContext, element, player, playerContextIndex, ref) {
+    ref = ref || element;
+    if (playerContextIndex) {
+        playerContext[playerContextIndex] = player;
+    }
+    else {
+        playerContext.push(player);
+    }
+    if (player) {
+        player.addEventListener(200 /* Destroyed */, function () {
+            var index = playerContext.indexOf(player);
+            var nonFactoryPlayerIndex = playerContext[0 /* NonBuilderPlayersStart */];
+            // if the player is being removed from the factory side of the context
+            // (which is where the [style] and [class] bindings do their thing) then
+            // that side of the array cannot be resized since the respective bindings
+            // have pointer index values that point to the associated factory instance
+            if (index) {
+                if (index < nonFactoryPlayerIndex) {
+                    playerContext[index] = null;
+                }
+                else {
+                    playerContext.splice(index, 1);
+                }
+            }
+            player.destroy();
+        });
+        var playerHandler = rootContext.playerHandler || (rootContext.playerHandler = new CorePlayerHandler());
+        playerHandler.queuePlayer(player, ref);
+        return true;
+    }
+    return false;
+}
+export function getPlayersInternal(playerContext) {
+    var players = [];
+    var nonFactoryPlayersStart = playerContext[0 /* NonBuilderPlayersStart */];
+    // add all factory-based players (which are apart of [style] and [class] bindings)
+    for (var i = 1 /* PlayerBuildersStartPosition */ + 1 /* PlayerOffsetPosition */; i < nonFactoryPlayersStart; i += 2 /* PlayerAndPlayerBuildersTupleSize */) {
+        var player = playerContext[i];
+        if (player) {
+            players.push(player);
+        }
+    }
+    // add all custom players (not apart of [style] and [class] bindings)
+    for (var i = nonFactoryPlayersStart; i < playerContext.length; i++) {
+        players.push(playerContext[i]);
+    }
+    return players;
+}
 export function getOrCreatePlayerContext(target, context) {
     context = context || getContext(target);
-    if (ngDevMode && !context) {
-        throw new Error('Only elements that exist in an Angular application can be used for player access');
+    if (!context) {
+        ngDevMode && throwInvalidRefError();
+        return null;
     }
     var lViewData = context.lViewData, nodeIndex = context.nodeIndex;
-    var value = lViewData[nodeIndex];
-    var stylingContext = value;
-    if (!Array.isArray(value)) {
-        stylingContext = lViewData[nodeIndex] = createEmptyStylingContext(value);
-    }
-    return stylingContext[1 /* PlayerContext */] || allocPlayerContext(stylingContext);
+    var stylingContext = getStylingContext(nodeIndex - HEADER_OFFSET, lViewData);
+    return getPlayerContext(stylingContext) || allocPlayerContext(stylingContext);
+}
+export function getPlayerContext(stylingContext) {
+    return stylingContext[0 /* PlayerContext */];
+}
+export function allocPlayerContext(data) {
+    return data[0 /* PlayerContext */] =
+        [5 /* SinglePlayerBuildersStartPosition */, null, null, null, null];
 }
-function allocPlayerContext(data) {
-    return data[1 /* PlayerContext */] = [];
+export function throwInvalidRefError() {
+    throw new Error('Only elements that exist in an Angular application can be used for animations');
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/core/src/render3/styling/util.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 '../ng_dev_mode';\n\nimport {StyleSanitizeFn} from '../../sanitization/style_sanitizer';\nimport {getContext} from '../context_discovery';\nimport {ACTIVE_INDEX, LContainer} from '../interfaces/container';\nimport {LContext} from '../interfaces/context';\nimport {PlayState, Player, PlayerContext, PlayerIndex} from '../interfaces/player';\nimport {RElement} from '../interfaces/renderer';\nimport {InitialStyles, StylingContext, StylingIndex} from '../interfaces/styling';\nimport {FLAGS, HEADER_OFFSET, HOST, LViewData, RootContext} from '../interfaces/view';\nimport {getTNode} from '../util';\n\nimport {CorePlayerHandler} from './core_player_handler';\n\nexport function createEmptyStylingContext(\n    element?: RElement | null, sanitizer?: StyleSanitizeFn | null,\n    initialStylingValues?: InitialStyles): StylingContext {\n  return [\n    null,                            // PlayerContext\n    sanitizer || null,               // StyleSanitizer\n    initialStylingValues || [null],  // InitialStyles\n    0,                               // MasterFlags\n    0,                               // ClassOffset\n    element || null,                 // Element\n    null,                            // PreviousMultiClassValue\n    null                             // PreviousMultiStyleValue\n  ];\n}\n\n/**\n * Used clone a copy of a pre-computed template of a styling context.\n *\n * A pre-computed template is designed to be computed once for a given element\n * (instructions.ts has logic for caching this).\n */\nexport function allocStylingContext(\n    element: RElement | null, templateStyleContext: StylingContext): StylingContext {\n  // each instance gets a copy\n  const context = templateStyleContext.slice() as any as StylingContext;\n  context[StylingIndex.ElementPosition] = element;\n  return context;\n}\n\n/**\n * Retrieve the `StylingContext` at a given index.\n *\n * This method lazily creates the `StylingContext`. This is because in most cases\n * we have styling without any bindings. Creating `StylingContext` eagerly would mean that\n * every style declaration such as `<div style=\"color: red\">` would result `StyleContext`\n * which would create unnecessary memory pressure.\n *\n * @param index Index of the style allocation. See: `elementStyling`.\n * @param viewData The view to search for the styling context\n */\nexport function getStylingContext(index: number, viewData: LViewData): StylingContext {\n  let storageIndex = index + HEADER_OFFSET;\n  let slotValue: LContainer|LViewData|StylingContext|RElement = viewData[storageIndex];\n  let wrapper: LContainer|LViewData|StylingContext = viewData;\n\n  while (Array.isArray(slotValue)) {\n    wrapper = slotValue;\n    slotValue = slotValue[HOST] as LViewData | StylingContext | RElement;\n  }\n\n  if (isStylingContext(wrapper)) {\n    return wrapper as StylingContext;\n  } else {\n    // This is an LViewData or an LContainer\n    const stylingTemplate = getTNode(index, viewData).stylingTemplate;\n\n    if (wrapper !== viewData) {\n      storageIndex = HOST;\n    }\n\n    return wrapper[storageIndex] = stylingTemplate ?\n        allocStylingContext(slotValue, stylingTemplate) :\n        createEmptyStylingContext(slotValue);\n  }\n}\n\nfunction isStylingContext(value: LViewData | LContainer | StylingContext) {\n  // Not an LViewData or an LContainer\n  return typeof value[FLAGS] !== 'number' && typeof value[ACTIVE_INDEX] !== 'number';\n}\n\nexport function addPlayerInternal(\n    playerContext: PlayerContext, rootContext: RootContext, element: HTMLElement,\n    player: Player | null, playerContextIndex: number, ref?: any): boolean {\n  ref = ref || element;\n  if (playerContextIndex) {\n    playerContext[playerContextIndex] = player;\n  } else {\n    playerContext.push(player);\n  }\n\n  if (player) {\n    player.addEventListener(PlayState.Destroyed, () => {\n      const index = playerContext.indexOf(player);\n      const nonFactoryPlayerIndex = playerContext[PlayerIndex.NonBuilderPlayersStart];\n\n      // if the player is being removed from the factory side of the context\n      // (which is where the [style] and [class] bindings do their thing) then\n      // that side of the array cannot be resized since the respective bindings\n      // have pointer index values that point to the associated factory instance\n      if (index) {\n        if (index < nonFactoryPlayerIndex) {\n          playerContext[index] = null;\n        } else {\n          playerContext.splice(index, 1);\n        }\n      }\n      player.destroy();\n    });\n\n    const playerHandler =\n        rootContext.playerHandler || (rootContext.playerHandler = new CorePlayerHandler());\n    playerHandler.queuePlayer(player, ref);\n    return true;\n  }\n\n  return false;\n}\n\nexport function getPlayersInternal(playerContext: PlayerContext): Player[] {\n  const players: Player[] = [];\n  const nonFactoryPlayersStart = playerContext[PlayerIndex.NonBuilderPlayersStart];\n\n  // add all factory-based players (which are apart of [style] and [class] bindings)\n  for (let i = PlayerIndex.PlayerBuildersStartPosition + PlayerIndex.PlayerOffsetPosition;\n       i < nonFactoryPlayersStart; i += PlayerIndex.PlayerAndPlayerBuildersTupleSize) {\n    const player = playerContext[i] as Player | null;\n    if (player) {\n      players.push(player);\n    }\n  }\n\n  // add all custom players (not apart of [style] and [class] bindings)\n  for (let i = nonFactoryPlayersStart; i < playerContext.length; i++) {\n    players.push(playerContext[i] as Player);\n  }\n\n  return players;\n}\n\n\nexport function getOrCreatePlayerContext(target: {}, context?: LContext | null): PlayerContext|\n    null {\n  context = context || getContext(target) !;\n  if (!context) {\n    ngDevMode && throwInvalidRefError();\n    return null;\n  }\n\n  const {lViewData, nodeIndex} = context;\n  const stylingContext = getStylingContext(nodeIndex - HEADER_OFFSET, lViewData);\n  return getPlayerContext(stylingContext) || allocPlayerContext(stylingContext);\n}\n\nexport function getPlayerContext(stylingContext: StylingContext): PlayerContext|null {\n  return stylingContext[StylingIndex.PlayerContext];\n}\n\nexport function allocPlayerContext(data: StylingContext): PlayerContext {\n  return data[StylingIndex.PlayerContext] =\n             [PlayerIndex.SinglePlayerBuildersStartPosition, null, null, null, null];\n}\n\nexport function throwInvalidRefError() {\n  throw new Error('Only elements that exist in an Angular application can be used for animations');\n}\n"]}

package/esm5/src/render3/util.js

@@ -7,8 +7,9 @@
  */
 import { devModeEqual } from '../change_detection/change_detection_util';
 import { assertDefined, assertLessThan } from './assert';
-import { readElementValue, readPatchedLViewData } from './context_discovery';
-import { CONTEXT, FLAGS, HEADER_OFFSET, PARENT } from './interfaces/view';
+import { ACTIVE_INDEX } from './interfaces/container';
+import { MONKEY_PATCH_KEY_NAME } from './interfaces/context';
+import { CONTEXT, FLAGS, HEADER_OFFSET, HOST, PARENT, TVIEW } from './interfaces/view';
 /**
  * Returns whether the values are different from a change detection stand point.
  *
@@ -31,15 +32,6 @@ export function stringify(value) {
         return '';
     return '' + value;
 }
-/**
- *  Function that throws a "not implemented" error so it's clear certain
- *  behaviors/methods aren't yet ready.
- *
- * @returns Not implemented error
- */
-export function notImplemented() {
-    return new Error('NotImplemented');
-}
 /**
  * Flattens an array in non-recursive way. Input arrays are not modified.
  */
@@ -72,24 +64,51 @@ export function loadInternal(index, arr) {
 export function assertDataInRangeInternal(index, arr) {
     assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');
 }
-/** Retrieves an element value from the provided `viewData`.
-  *
-  * Elements that are read may be wrapped in a style context,
-  * therefore reading the value may involve unwrapping that.
-  */
-export function loadElementInternal(index, arr) {
-    var value = loadInternal(index, arr);
-    return readElementValue(value);
+/**
+ * Takes the value of a slot in `LViewData` and returns the element node.
+ *
+ * Normally, element nodes are stored flat, but if the node has styles/classes on it,
+ * it might be wrapped in a styling context. Or if that node has a directive that injects
+ * ViewContainerRef, it may be wrapped in an LContainer. Or if that node is a component,
+ * it will be wrapped in LViewData. It could even have all three, so we keep looping
+ * until we find something that isn't an array.
+ *
+ * @param value The initial value in `LViewData`
+ */
+export function readElementValue(value) {
+    while (Array.isArray(value)) {
+        value = value[HOST];
+    }
+    return value;
+}
+/**
+ * Retrieves an element value from the provided `viewData`, by unwrapping
+ * from any containers, component views, or style contexts.
+ */
+export function getNativeByIndex(index, arr) {
+    return readElementValue(arr[index + HEADER_OFFSET]);
 }
-export function getLNode(tNode, hostView) {
+export function getNativeByTNode(tNode, hostView) {
     return readElementValue(hostView[tNode.index]);
 }
+export function getTNode(index, view) {
+    return view[TVIEW].data[index + HEADER_OFFSET];
+}
+export function getComponentViewByIndex(nodeIndex, hostView) {
+    // Could be an LViewData or an LContainer. If LContainer, unwrap to find LViewData.
+    var slotValue = hostView[nodeIndex];
+    return slotValue.length >= HEADER_OFFSET ? slotValue : slotValue[HOST];
+}
 export function isContentQueryHost(tNode) {
     return (tNode.flags & 16384 /* hasContentQuery */) !== 0;
 }
 export function isComponent(tNode) {
     return (tNode.flags & 4096 /* isComponent */) === 4096 /* isComponent */;
 }
+export function isLContainer(value) {
+    // Styling contexts are also arrays, but their first index contains an element node
+    return Array.isArray(value) && typeof value[ACTIVE_INDEX] === 'number';
+}
 /**
  * Retrieve the root view from any component by walking the parent `LViewData` until
  * reaching the root `LViewData`.
@@ -107,5 +126,19 @@ export function getRootView(target) {
 export function getRootContext(viewOrComponent) {
     return getRootView(viewOrComponent)[CONTEXT];
 }
+/**
+ * Returns the monkey-patch value data present on the target (which could be
+ * a component, directive or a DOM node).
+ */
+export function readPatchedData(target) {
+    return target[MONKEY_PATCH_KEY_NAME];
+}
+export function readPatchedLViewData(target) {
+    var value = readPatchedData(target);
+    if (value) {
+        return Array.isArray(value) ? value : value.lViewData;
+    }
+    return null;
+}
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/render3/util.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 {devModeEqual} from '../change_detection/change_detection_util';\n\nimport {assertDefined, assertLessThan} from './assert';\nimport {readElementValue, readPatchedLViewData} from './context_discovery';\nimport {LContainerNode, LElementContainerNode, LElementNode, TNode, TNodeFlags} from './interfaces/node';\nimport {CONTEXT, FLAGS, HEADER_OFFSET, LViewData, LViewFlags, PARENT, RootContext, TData, TVIEW} from './interfaces/view';\n\n\n\n/**\n * Returns whether the values are different from a change detection stand point.\n *\n * Constraints are relaxed in checkNoChanges mode. See `devModeEqual` for details.\n */\nexport function isDifferent(a: any, b: any, checkNoChangesMode: boolean): boolean {\n  if (ngDevMode && checkNoChangesMode) {\n    return !devModeEqual(a, b);\n  }\n  // NaN is the only value that is not equal to itself so the first\n  // test checks if both a and b are not NaN\n  return !(a !== a && b !== b) && a !== b;\n}\n\nexport function stringify(value: any): string {\n  if (typeof value == 'function') return value.name || value;\n  if (typeof value == 'string') return value;\n  if (value == null) return '';\n  return '' + value;\n}\n\n/**\n *  Function that throws a \"not implemented\" error so it's clear certain\n *  behaviors/methods aren't yet ready.\n *\n * @returns Not implemented error\n */\nexport function notImplemented(): Error {\n  return new Error('NotImplemented');\n}\n\n/**\n * Flattens an array in non-recursive way. Input arrays are not modified.\n */\nexport function flatten(list: any[]): any[] {\n  const result: any[] = [];\n  let i = 0;\n\n  while (i < list.length) {\n    const item = list[i];\n    if (Array.isArray(item)) {\n      if (item.length > 0) {\n        list = item.concat(list.slice(i + 1));\n        i = 0;\n      } else {\n        i++;\n      }\n    } else {\n      result.push(item);\n      i++;\n    }\n  }\n\n  return result;\n}\n\n/** Retrieves a value from any `LViewData` or `TData`. */\nexport function loadInternal<T>(index: number, arr: LViewData | TData): T {\n  ngDevMode && assertDataInRangeInternal(index + HEADER_OFFSET, arr);\n  return arr[index + HEADER_OFFSET];\n}\n\nexport function assertDataInRangeInternal(index: number, arr: any[]) {\n  assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');\n}\n\n/** Retrieves an element value from the provided `viewData`.\n  *\n  * Elements that are read may be wrapped in a style context,\n  * therefore reading the value may involve unwrapping that.\n  */\nexport function loadElementInternal(index: number, arr: LViewData): LElementNode {\n  const value = loadInternal<LElementNode>(index, arr);\n  return readElementValue(value);\n}\n\nexport function getLNode(tNode: TNode, hostView: LViewData): LElementNode|LContainerNode|\n    LElementContainerNode {\n  return readElementValue(hostView[tNode.index]);\n}\n\nexport function isContentQueryHost(tNode: TNode): boolean {\n  return (tNode.flags & TNodeFlags.hasContentQuery) !== 0;\n}\n\nexport function isComponent(tNode: TNode): boolean {\n  return (tNode.flags & TNodeFlags.isComponent) === TNodeFlags.isComponent;\n}\n/**\n * Retrieve the root view from any component by walking the parent `LViewData` until\n * reaching the root `LViewData`.\n *\n * @param component any component\n */\nexport function getRootView(target: LViewData | {}): LViewData {\n  ngDevMode && assertDefined(target, 'component');\n  let lViewData = Array.isArray(target) ? (target as LViewData) : readPatchedLViewData(target) !;\n  while (lViewData && !(lViewData[FLAGS] & LViewFlags.IsRoot)) {\n    lViewData = lViewData[PARENT] !;\n  }\n  return lViewData;\n}\n\nexport function getRootContext(viewOrComponent: LViewData | {}): RootContext {\n  return getRootView(viewOrComponent)[CONTEXT] as RootContext;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/render3/util.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 {devModeEqual} from '../change_detection/change_detection_util';\n\nimport {assertDefined, assertLessThan} from './assert';\nimport {ACTIVE_INDEX, LContainer} from './interfaces/container';\nimport {LContext, MONKEY_PATCH_KEY_NAME} from './interfaces/context';\nimport {TNode, TNodeFlags} from './interfaces/node';\nimport {RComment, RElement, RText} from './interfaces/renderer';\nimport {StylingContext} from './interfaces/styling';\nimport {CONTEXT, FLAGS, HEADER_OFFSET, HOST, LViewData, LViewFlags, PARENT, RootContext, TData, TVIEW} from './interfaces/view';\n\n\n/**\n * Returns whether the values are different from a change detection stand point.\n *\n * Constraints are relaxed in checkNoChanges mode. See `devModeEqual` for details.\n */\nexport function isDifferent(a: any, b: any, checkNoChangesMode: boolean): boolean {\n  if (ngDevMode && checkNoChangesMode) {\n    return !devModeEqual(a, b);\n  }\n  // NaN is the only value that is not equal to itself so the first\n  // test checks if both a and b are not NaN\n  return !(a !== a && b !== b) && a !== b;\n}\n\nexport function stringify(value: any): string {\n  if (typeof value == 'function') return value.name || value;\n  if (typeof value == 'string') return value;\n  if (value == null) return '';\n  return '' + value;\n}\n\n/**\n * Flattens an array in non-recursive way. Input arrays are not modified.\n */\nexport function flatten(list: any[]): any[] {\n  const result: any[] = [];\n  let i = 0;\n\n  while (i < list.length) {\n    const item = list[i];\n    if (Array.isArray(item)) {\n      if (item.length > 0) {\n        list = item.concat(list.slice(i + 1));\n        i = 0;\n      } else {\n        i++;\n      }\n    } else {\n      result.push(item);\n      i++;\n    }\n  }\n\n  return result;\n}\n\n/** Retrieves a value from any `LViewData` or `TData`. */\nexport function loadInternal<T>(index: number, arr: LViewData | TData): T {\n  ngDevMode && assertDataInRangeInternal(index + HEADER_OFFSET, arr);\n  return arr[index + HEADER_OFFSET];\n}\n\nexport function assertDataInRangeInternal(index: number, arr: any[]) {\n  assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');\n}\n\n/**\n * Takes the value of a slot in `LViewData` and returns the element node.\n *\n * Normally, element nodes are stored flat, but if the node has styles/classes on it,\n * it might be wrapped in a styling context. Or if that node has a directive that injects\n * ViewContainerRef, it may be wrapped in an LContainer. Or if that node is a component,\n * it will be wrapped in LViewData. It could even have all three, so we keep looping\n * until we find something that isn't an array.\n *\n * @param value The initial value in `LViewData`\n */\nexport function readElementValue(value: RElement | StylingContext | LContainer | LViewData):\n    RElement {\n  while (Array.isArray(value)) {\n    value = value[HOST] as any;\n  }\n  return value;\n}\n\n/**\n * Retrieves an element value from the provided `viewData`, by unwrapping\n * from any containers, component views, or style contexts.\n */\nexport function getNativeByIndex(index: number, arr: LViewData): RElement {\n  return readElementValue(arr[index + HEADER_OFFSET]);\n}\n\nexport function getNativeByTNode(tNode: TNode, hostView: LViewData): RElement|RText|RComment {\n  return readElementValue(hostView[tNode.index]);\n}\n\nexport function getTNode(index: number, view: LViewData): TNode {\n  return view[TVIEW].data[index + HEADER_OFFSET] as TNode;\n}\n\nexport function getComponentViewByIndex(nodeIndex: number, hostView: LViewData): LViewData {\n  // Could be an LViewData or an LContainer. If LContainer, unwrap to find LViewData.\n  const slotValue = hostView[nodeIndex];\n  return slotValue.length >= HEADER_OFFSET ? slotValue : slotValue[HOST];\n}\n\nexport function isContentQueryHost(tNode: TNode): boolean {\n  return (tNode.flags & TNodeFlags.hasContentQuery) !== 0;\n}\n\nexport function isComponent(tNode: TNode): boolean {\n  return (tNode.flags & TNodeFlags.isComponent) === TNodeFlags.isComponent;\n}\n\nexport function isLContainer(value: RElement | RComment | LContainer | StylingContext): boolean {\n  // Styling contexts are also arrays, but their first index contains an element node\n  return Array.isArray(value) && typeof value[ACTIVE_INDEX] === 'number';\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 component any component\n */\nexport function getRootView(target: LViewData | {}): LViewData {\n  ngDevMode && assertDefined(target, 'component');\n  let lViewData = Array.isArray(target) ? (target as LViewData) : readPatchedLViewData(target) !;\n  while (lViewData && !(lViewData[FLAGS] & LViewFlags.IsRoot)) {\n    lViewData = lViewData[PARENT] !;\n  }\n  return lViewData;\n}\n\nexport function getRootContext(viewOrComponent: LViewData | {}): RootContext {\n  return getRootView(viewOrComponent)[CONTEXT] as RootContext;\n}\n\n/**\n * Returns the monkey-patch value data present on the target (which could be\n * a component, directive or a DOM node).\n */\nexport function readPatchedData(target: any): LViewData|LContext|null {\n  return target[MONKEY_PATCH_KEY_NAME];\n}\n\nexport function readPatchedLViewData(target: any): LViewData|null {\n  const value = readPatchedData(target);\n  if (value) {\n    return Array.isArray(value) ? value : (value as LContext).lViewData;\n  }\n  return null;\n}\n"]}