@angular/core 7.1.3 → 7.1.4

package/esm2015/src/render3/interfaces/player.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -14,22 +14,36 @@
  * @record
  */
 export function Player() { }
-/** @type {?|undefined} */
-Player.prototype.parent;
-/** @type {?} */
-Player.prototype.state;
-/** @type {?} */
-Player.prototype.play;
-/** @type {?} */
-Player.prototype.pause;
-/** @type {?} */
-Player.prototype.finish;
-/** @type {?} */
-Player.prototype.destroy;
-/** @type {?} */
-Player.prototype.addEventListener;
+if (false) {
+    /** @type {?|undefined} */
+    Player.prototype.parent;
+    /** @type {?} */
+    Player.prototype.state;
+    /**
+     * @return {?}
+     */
+    Player.prototype.play = function () { };
+    /**
+     * @return {?}
+     */
+    Player.prototype.pause = function () { };
+    /**
+     * @return {?}
+     */
+    Player.prototype.finish = function () { };
+    /**
+     * @return {?}
+     */
+    Player.prototype.destroy = function () { };
+    /**
+     * @param {?} state
+     * @param {?} cb
+     * @return {?}
+     */
+    Player.prototype.addEventListener = function (state, cb) { };
+}
 /** @enum {number} */
-var BindingType = {
+const BindingType = {
     Unset: 0,
     Class: 1,
     Style: 2,
@@ -39,8 +53,14 @@ export { BindingType };
  * @record
  */
 export function BindingStore() { }
-/** @type {?} */
-BindingStore.prototype.setValue;
+if (false) {
+    /**
+     * @param {?} prop
+     * @param {?} value
+     * @return {?}
+     */
+    BindingStore.prototype.setValue = function (prop, value) { };
+}
 /**
  * Defines the shape which produces the Player.
  *
@@ -63,16 +83,24 @@ export function PlayerFactoryBuildFn() { }
  * @record
  */
 export function PlayerFactory() { }
-/** @type {?} */
-PlayerFactory.prototype.__brand__;
+if (false) {
+    /** @type {?} */
+    PlayerFactory.prototype.__brand__;
+}
 /**
  * @record
  */
 export function PlayerBuilder() { }
-/** @type {?} */
-PlayerBuilder.prototype.buildPlayer;
+if (false) {
+    /**
+     * @param {?} currentPlayer
+     * @param {?} isFirstRender
+     * @return {?}
+     */
+    PlayerBuilder.prototype.buildPlayer = function (currentPlayer, isFirstRender) { };
+}
 /** @enum {number} */
-var PlayState = {
+const PlayState = {
     Pending: 0, Running: 1, Paused: 2, Finished: 100, Destroyed: 200,
 };
 export { PlayState };
@@ -81,6 +109,18 @@ export { PlayState };
  * @record
  */
 export function PlayerContext() { }
+if (false) {
+    /* Skipping unnamed member:
+    [PlayerIndex.NonBuilderPlayersStart]: number;*/
+    /* Skipping unnamed member:
+    [PlayerIndex.ClassMapPlayerBuilderPosition]: PlayerBuilder|null;*/
+    /* Skipping unnamed member:
+    [PlayerIndex.ClassMapPlayerPosition]: Player|null;*/
+    /* Skipping unnamed member:
+    [PlayerIndex.StyleMapPlayerBuilderPosition]: PlayerBuilder|null;*/
+    /* Skipping unnamed member:
+    [PlayerIndex.StyleMapPlayerPosition]: Player|null;*/
+}
 /**
  * Designed to be used as an injection service to capture all animation players.
  *
@@ -90,19 +130,21 @@ export function PlayerContext() { }
  * @record
  */
 export function PlayerHandler() { }
-/**
- * Designed to kick off the player at the end of change detection
- * @type {?}
- */
-PlayerHandler.prototype.flushPlayers;
-/**
- * \@param player The player that has been scheduled to run within the application.
- * \@param context The context as to where the player was bound to
- * @type {?}
- */
-PlayerHandler.prototype.queuePlayer;
+if (false) {
+    /**
+     * Designed to kick off the player at the end of change detection
+     * @return {?}
+     */
+    PlayerHandler.prototype.flushPlayers = function () { };
+    /**
+     * @param {?} player The player that has been scheduled to run within the application.
+     * @param {?} context The context as to where the player was bound to
+     * @return {?}
+     */
+    PlayerHandler.prototype.queuePlayer = function (player, context) { };
+}
 /** @enum {number} */
-var PlayerIndex = {
+const PlayerIndex = {
     // The position where the index that reveals where players start in the PlayerContext
     NonBuilderPlayersStart: 0,
     // The position where the player builder lives (which handles {key:value} map expression) for
@@ -125,5 +167,4 @@ var PlayerIndex = {
     PlayerOffsetPosition: 1,
 };
 export { PlayerIndex };
-
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/render3/interfaces/projection.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,14 +9,8 @@
  * 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
  */
-/** @typedef {?} */
-var CssSelector;
-export { CssSelector };
-/** @typedef {?} */
-var CssSelectorList;
-export { CssSelectorList };
 /** @enum {number} */
-var SelectorFlags = {
+const SelectorFlags = {
     /** Indicates this is the beginning of a new negative selector */
     NOT: 1,
     /** Mode for matching attributes */
@@ -29,7 +23,8 @@ var SelectorFlags = {
 export { SelectorFlags };
 /** @type {?} */
 export const NG_PROJECT_AS_ATTR_NAME = 'ngProjectAs';
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/render3/interfaces/query.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -14,64 +14,70 @@
  * @record
  */
 export function LQueries() { }
-/**
- * The parent LQueries instance.
- *
- * When there is a content query, a new LQueries instance is created to avoid mutating any
- * existing LQueries. After we are done searching content children, the parent property allows
- * us to traverse back up to the original LQueries instance to continue to search for matches
- * in the main view.
- * @type {?}
- */
-LQueries.prototype.parent;
-/**
- * Ask queries to prepare copy of itself. This assures that tracking new queries on content nodes
- * doesn't mutate list of queries tracked on a parent node. We will clone LQueries before
- * constructing content queries.
- * @type {?}
- */
-LQueries.prototype.clone;
-/**
- * Notify `LQueries` that a new `TNode` has been created and needs to be added to query results
- * if matching query predicate.
- * @type {?}
- */
-LQueries.prototype.addNode;
-/**
- * Notify `LQueries` that a new LContainer was added to ivy data structures. As a result we need
- * to prepare room for views that might be inserted into this container.
- * @type {?}
- */
-LQueries.prototype.container;
-/**
- * Notify `LQueries` that a new `LView` has been created. As a result we need to prepare room
- * and collect nodes that match query predicate.
- * @type {?}
- */
-LQueries.prototype.createView;
-/**
- * Notify `LQueries` that a new `LView` has been added to `LContainer`. As a result all
- * the matching nodes from this view should be added to container's queries.
- * @type {?}
- */
-LQueries.prototype.insertView;
-/**
- * Notify `LQueries` that an `LView` has been removed from `LContainer`. As a result all
- * the matching nodes from this view should be removed from container's queries.
- * @type {?}
- */
-LQueries.prototype.removeView;
-/**
- * Add additional `QueryList` to track.
- *
- * \@param queryList `QueryList` to update with changes.
- * \@param predicate Either `Type` or selector array of [key, value] predicates.
- * \@param descend If true the query will recursively apply to the children.
- * \@param read Indicates which token should be read from DI for this query.
- * @type {?}
- */
-LQueries.prototype.track;
+if (false) {
+    /**
+     * The parent LQueries instance.
+     *
+     * When there is a content query, a new LQueries instance is created to avoid mutating any
+     * existing LQueries. After we are done searching content children, the parent property allows
+     * us to traverse back up to the original LQueries instance to continue to search for matches
+     * in the main view.
+     * @type {?}
+     */
+    LQueries.prototype.parent;
+    /**
+     * Ask queries to prepare copy of itself. This assures that tracking new queries on content nodes
+     * doesn't mutate list of queries tracked on a parent node. We will clone LQueries before
+     * constructing content queries.
+     * @return {?}
+     */
+    LQueries.prototype.clone = function () { };
+    /**
+     * Notify `LQueries` that a new `TNode` has been created and needs to be added to query results
+     * if matching query predicate.
+     * @param {?} tNode
+     * @return {?}
+     */
+    LQueries.prototype.addNode = function (tNode) { };
+    /**
+     * Notify `LQueries` that a new LContainer was added to ivy data structures. As a result we need
+     * to prepare room for views that might be inserted into this container.
+     * @return {?}
+     */
+    LQueries.prototype.container = function () { };
+    /**
+     * Notify `LQueries` that a new `LView` has been created. As a result we need to prepare room
+     * and collect nodes that match query predicate.
+     * @return {?}
+     */
+    LQueries.prototype.createView = function () { };
+    /**
+     * Notify `LQueries` that a new `LView` has been added to `LContainer`. As a result all
+     * the matching nodes from this view should be added to container's queries.
+     * @param {?} newViewIndex
+     * @return {?}
+     */
+    LQueries.prototype.insertView = function (newViewIndex) { };
+    /**
+     * Notify `LQueries` that an `LView` has been removed from `LContainer`. As a result all
+     * the matching nodes from this view should be removed from container's queries.
+     * @return {?}
+     */
+    LQueries.prototype.removeView = function () { };
+    /**
+     * Add additional `QueryList` to track.
+     *
+     * @template T
+     * @param {?} queryList `QueryList` to update with changes.
+     * @param {?} predicate Either `Type` or selector array of [key, value] predicates.
+     * @param {?=} descend If true the query will recursively apply to the children.
+     * @param {?=} read Indicates which token should be read from DI for this query.
+     * @return {?}
+     */
+    LQueries.prototype.track = function (queryList, predicate, descend, read) { };
+}
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
-
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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