@angular/core 7.0.0-rc.1 → 7.0.3

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

@@ -13,7 +13,7 @@ export class CorePlayerHandler {
         for (let i = 0; i < this._players.length; i++) {
             /** @type {?} */
             const player = this._players[i];
-            if (!player.parent) {
+            if (!player.parent && player.state === 0 /* Pending */) {
                 player.play();
             }
         }
@@ -30,4 +30,4 @@ if (false) {
     CorePlayerHandler.prototype._players;
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZV9wbGF5ZXJfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvc3R5bGluZy9jb3JlX3BsYXllcl9oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFTQSxNQUFNLE9BQU8saUJBQWlCOzt3QkFDQyxFQUFFOzs7OztJQUUvQixZQUFZO1FBQ1YsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFOztZQUM3QyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ2hDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFO2dCQUNsQixNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7YUFDZjtTQUNGO1FBQ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0tBQzFCOzs7OztJQUVELFdBQVcsQ0FBQyxNQUFjLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRTtDQUM1RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7UGxheWVyLCBQbGF5ZXJIYW5kbGVyfSBmcm9tICcuLi9pbnRlcmZhY2VzL3BsYXllcic7XG5cbmV4cG9ydCBjbGFzcyBDb3JlUGxheWVySGFuZGxlciBpbXBsZW1lbnRzIFBsYXllckhhbmRsZXIge1xuICBwcml2YXRlIF9wbGF5ZXJzOiBQbGF5ZXJbXSA9IFtdO1xuXG4gIGZsdXNoUGxheWVycygpIHtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHRoaXMuX3BsYXllcnMubGVuZ3RoOyBpKyspIHtcbiAgICAgIGNvbnN0IHBsYXllciA9IHRoaXMuX3BsYXllcnNbaV07XG4gICAgICBpZiAoIXBsYXllci5wYXJlbnQpIHtcbiAgICAgICAgcGxheWVyLnBsYXkoKTtcbiAgICAgIH1cbiAgICB9XG4gICAgdGhpcy5fcGxheWVycy5sZW5ndGggPSAwO1xuICB9XG5cbiAgcXVldWVQbGF5ZXIocGxheWVyOiBQbGF5ZXIpIHsgdGhpcy5fcGxheWVycy5wdXNoKHBsYXllcik7IH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZV9wbGF5ZXJfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvc3R5bGluZy9jb3JlX3BsYXllcl9oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFTQSxNQUFNLE9BQU8saUJBQWlCOzt3QkFDQyxFQUFFOzs7OztJQUUvQixZQUFZO1FBQ1YsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFOztZQUM3QyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ2hDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxJQUFJLE1BQU0sQ0FBQyxLQUFLLG9CQUFzQixFQUFFO2dCQUN4RCxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7YUFDZjtTQUNGO1FBQ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0tBQzFCOzs7OztJQUVELFdBQVcsQ0FBQyxNQUFjLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRTtDQUM1RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7UGxheVN0YXRlLCBQbGF5ZXIsIFBsYXllckhhbmRsZXJ9IGZyb20gJy4uL2ludGVyZmFjZXMvcGxheWVyJztcblxuZXhwb3J0IGNsYXNzIENvcmVQbGF5ZXJIYW5kbGVyIGltcGxlbWVudHMgUGxheWVySGFuZGxlciB7XG4gIHByaXZhdGUgX3BsYXllcnM6IFBsYXllcltdID0gW107XG5cbiAgZmx1c2hQbGF5ZXJzKCkge1xuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgdGhpcy5fcGxheWVycy5sZW5ndGg7IGkrKykge1xuICAgICAgY29uc3QgcGxheWVyID0gdGhpcy5fcGxheWVyc1tpXTtcbiAgICAgIGlmICghcGxheWVyLnBhcmVudCAmJiBwbGF5ZXIuc3RhdGUgPT09IFBsYXlTdGF0ZS5QZW5kaW5nKSB7XG4gICAgICAgIHBsYXllci5wbGF5KCk7XG4gICAgICB9XG4gICAgfVxuICAgIHRoaXMuX3BsYXllcnMubGVuZ3RoID0gMDtcbiAgfVxuXG4gIHF1ZXVlUGxheWVyKHBsYXllcjogUGxheWVyKSB7IHRoaXMuX3BsYXllcnMucHVzaChwbGF5ZXIpOyB9XG59XG4iXX0=

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

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ */
+/**
+ * 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.
+ *
+ * @template T
+ * @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.
+ * @return {?}
+ */
+export function bindPlayerFactory(factoryFn, value) {
+    return /** @type {?} */ (new BoundPlayerFactory(factoryFn, value));
+}
+/**
+ * @template T
+ */
+export class BoundPlayerFactory {
+    /**
+     * @param {?} fn
+     * @param {?} value
+     */
+    constructor(fn, value) {
+        this.fn = fn;
+        this.value = value;
+    }
+}
+if (false) {
+    /** @type {?} */
+    BoundPlayerFactory.prototype.__brand__;
+    /** @type {?} */
+    BoundPlayerFactory.prototype.fn;
+    /** @type {?} */
+    BoundPlayerFactory.prototype.value;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -2,11 +2,12 @@
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
  */
+import '../ng_dev_mode';
 import { getContext } from '../context_discovery';
-/** @type {?} */
-export const EMPTY_ARR = [];
-/** @type {?} */
-export const 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';
 /**
  * @param {?=} element
  * @param {?=} sanitizer
@@ -15,9 +16,146 @@ export const EMPTY_OBJ = {};
  */
 export function createEmptyStylingContext(element, sanitizer, initialStylingValues) {
     return [
-        element || null, null, sanitizer || null, initialStylingValues || [null], 0, 0, null, null
+        null,
+        // PlayerContext
+        sanitizer || null,
+        // StyleSanitizer
+        initialStylingValues || [null],
+        0,
+        0,
+        // ClassOffset
+        element || null,
+        null,
+        null
     ];
 }
+/**
+ * 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).
+ * @param {?} element
+ * @param {?} templateStyleContext
+ * @return {?}
+ */
+export function allocStylingContext(element, templateStyleContext) {
+    /** @type {?} */
+    const context = /** @type {?} */ ((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
+ * @return {?}
+ */
+export function getStylingContext(index, viewData) {
+    /** @type {?} */
+    let storageIndex = index + HEADER_OFFSET;
+    /** @type {?} */
+    let slotValue = viewData[storageIndex];
+    /** @type {?} */
+    let wrapper = viewData;
+    while (Array.isArray(slotValue)) {
+        wrapper = slotValue;
+        slotValue = /** @type {?} */ (slotValue[HOST]);
+    }
+    if (isStylingContext(wrapper)) {
+        return /** @type {?} */ (wrapper);
+    }
+    else {
+        /** @type {?} */
+        const stylingTemplate = getTNode(index, viewData).stylingTemplate;
+        if (wrapper !== viewData) {
+            storageIndex = HOST;
+        }
+        return wrapper[storageIndex] = stylingTemplate ?
+            allocStylingContext(slotValue, stylingTemplate) :
+            createEmptyStylingContext(slotValue);
+    }
+}
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function isStylingContext(value) {
+    // Not an LViewData or an LContainer
+    return typeof value[FLAGS] !== 'number' && typeof value[ACTIVE_INDEX] !== 'number';
+}
+/**
+ * @param {?} playerContext
+ * @param {?} rootContext
+ * @param {?} element
+ * @param {?} player
+ * @param {?} playerContextIndex
+ * @param {?=} ref
+ * @return {?}
+ */
+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 */, () => {
+            /** @type {?} */
+            const index = playerContext.indexOf(player);
+            /** @type {?} */
+            const 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();
+        });
+        /** @type {?} */
+        const playerHandler = rootContext.playerHandler || (rootContext.playerHandler = new CorePlayerHandler());
+        playerHandler.queuePlayer(player, ref);
+        return true;
+    }
+    return false;
+}
+/**
+ * @param {?} playerContext
+ * @return {?}
+ */
+export function getPlayersInternal(playerContext) {
+    /** @type {?} */
+    const players = [];
+    /** @type {?} */
+    const nonFactoryPlayersStart = playerContext[0 /* NonBuilderPlayersStart */];
+    // add all factory-based players (which are apart of [style] and [class] bindings)
+    for (let i = 1 /* PlayerBuildersStartPosition */ + 1 /* PlayerOffsetPosition */; i < nonFactoryPlayersStart; i += 2 /* PlayerAndPlayerBuildersTupleSize */) {
+        /** @type {?} */
+        const player = /** @type {?} */ (playerContext[i]);
+        if (player) {
+            players.push(player);
+        }
+    }
+    // add all custom players (not apart of [style] and [class] bindings)
+    for (let i = nonFactoryPlayersStart; i < playerContext.length; i++) {
+        players.push(/** @type {?} */ (playerContext[i]));
+    }
+    return players;
+}
 /**
  * @param {?} target
  * @param {?=} context
@@ -25,25 +163,35 @@ export function createEmptyStylingContext(element, sanitizer, initialStylingValu
  */
 export function getOrCreatePlayerContext(target, context) {
     context = context || /** @type {?} */ ((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;
     }
     const { lViewData, nodeIndex } = context;
     /** @type {?} */
-    const value = lViewData[nodeIndex];
-    /** @type {?} */
-    let stylingContext = /** @type {?} */ (value);
-    if (!Array.isArray(value)) {
-        stylingContext = lViewData[nodeIndex] = createEmptyStylingContext(/** @type {?} */ (value));
-    }
-    return stylingContext[1 /* PlayerContext */] || allocPlayerContext(stylingContext);
+    const stylingContext = getStylingContext(nodeIndex - HEADER_OFFSET, lViewData);
+    return getPlayerContext(stylingContext) || allocPlayerContext(stylingContext);
+}
+/**
+ * @param {?} stylingContext
+ * @return {?}
+ */
+export function getPlayerContext(stylingContext) {
+    return stylingContext[0 /* PlayerContext */];
 }
 /**
  * @param {?} data
  * @return {?}
  */
-function allocPlayerContext(data) {
-    return data[1 /* PlayerContext */] = [];
+export function allocPlayerContext(data) {
+    return data[0 /* PlayerContext */] =
+        [5 /* SinglePlayerBuildersStartPosition */, null, null, null, null];
+}
+/**
+ * @return {?}
+ */
+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/esm2015/src/render3/util.js

@@ -11,8 +11,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.
  *
@@ -43,15 +44,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.
- *
- * @return {?} Not implemented error
- */
-export function notImplemented() {
-    return new Error('NotImplemented');
-}
 /**
  * Flattens an array in non-recursive way. Input arrays are not modified.
  * @param {?} list
@@ -101,27 +93,59 @@ 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`.
+ * 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.
  *
- * Elements that are read may be wrapped in a style context,
- * therefore reading the value may involve unwrapping that.
+ * @param {?} value The initial value in `LViewData`
+ * @return {?}
+ */
+export function readElementValue(value) {
+    while (Array.isArray(value)) {
+        value = /** @type {?} */ (value[HOST]);
+    }
+    return value;
+}
+/**
+ * Retrieves an element value from the provided `viewData`, by unwrapping
+ * from any containers, component views, or style contexts.
  * @param {?} index
  * @param {?} arr
  * @return {?}
  */
-export function loadElementInternal(index, arr) {
-    /** @type {?} */
-    const value = loadInternal(index, arr);
-    return readElementValue(value);
+export function getNativeByIndex(index, arr) {
+    return readElementValue(arr[index + HEADER_OFFSET]);
 }
 /**
  * @param {?} tNode
  * @param {?} hostView
  * @return {?}
  */
-export function getLNode(tNode, hostView) {
+export function getNativeByTNode(tNode, hostView) {
     return readElementValue(hostView[tNode.index]);
 }
+/**
+ * @param {?} index
+ * @param {?} view
+ * @return {?}
+ */
+export function getTNode(index, view) {
+    return /** @type {?} */ (view[TVIEW].data[index + HEADER_OFFSET]);
+}
+/**
+ * @param {?} nodeIndex
+ * @param {?} hostView
+ * @return {?}
+ */
+export function getComponentViewByIndex(nodeIndex, hostView) {
+    /** @type {?} */
+    const slotValue = hostView[nodeIndex];
+    return slotValue.length >= HEADER_OFFSET ? slotValue : slotValue[HOST];
+}
 /**
  * @param {?} tNode
  * @return {?}
@@ -136,6 +160,14 @@ export function isContentQueryHost(tNode) {
 export function isComponent(tNode) {
     return (tNode.flags & 4096 /* isComponent */) === 4096 /* isComponent */;
 }
+/**
+ * @param {?} value
+ * @return {?}
+ */
+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`.
@@ -159,5 +191,26 @@ export function getRootView(target) {
 export function getRootContext(viewOrComponent) {
     return /** @type {?} */ (getRootView(viewOrComponent)[CONTEXT]);
 }
+/**
+ * Returns the monkey-patch value data present on the target (which could be
+ * a component, directive or a DOM node).
+ * @param {?} target
+ * @return {?}
+ */
+export function readPatchedData(target) {
+    return target[MONKEY_PATCH_KEY_NAME];
+}
+/**
+ * @param {?} target
+ * @return {?}
+ */
+export function readPatchedLViewData(target) {
+    /** @type {?} */
+    const value = readPatchedData(target);
+    if (value) {
+        return Array.isArray(value) ? value : (/** @type {?} */ (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"]}