http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/d07dd0f2/node_modules/@angular/animations/bundles/animations-browser.umd.js ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/bundles/animations-browser.umd.js b/node_modules/@angular/animations/bundles/animations-browser.umd.js index 7a11496..a4a5e7f 100644 --- a/node_modules/@angular/animations/bundles/animations-browser.umd.js +++ b/node_modules/@angular/animations/bundles/animations-browser.umd.js @@ -1,12 +1,12 @@ /** - * @license Angular v4.4.6 - * (c) 2010-2017 Google, Inc. https://angular.io/ + * @license Angular v5.2.0 + * (c) 2010-2018 Google, Inc. https://angular.io/ * License: MIT */ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/animations')) : - typeof define === 'function' && define.amd ? define(['exports', '@angular/animations'], factory) : - (factory((global.ng = global.ng || {}, global.ng.animations = global.ng.animations || {}, global.ng.animations.browser = global.ng.animations.browser || {}),global.ng.animations)); + typeof define === 'function' && define.amd ? define('@angular/animations/browser', ['exports', '@angular/animations'], factory) : + (factory((global.ng = global.ng || {}, global.ng.animations = global.ng.animations || {}, global.ng.animations.browser = {}),global.ng.animations)); }(this, (function (exports,_angular_animations) { 'use strict'; /*! ***************************************************************************** @@ -33,19 +33,28 @@ function __extends(d, b) { extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); -} +} + +var __assign = Object.assign || function __assign(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; +}; /** - * @license Angular v4.4.6 - * (c) 2010-2017 Google, Inc. https://angular.io/ + * @license Angular v5.2.0 + * (c) 2010-2018 Google, Inc. https://angular.io/ * License: MIT */ /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ +/** + * @param {?} players + * @return {?} */ function optimizeGroupPlayer(players) { switch (players.length) { @@ -57,20 +66,29 @@ function optimizeGroupPlayer(players) { return new _angular_animations.ɵAnimationGroupPlayer(players); } } +/** + * @param {?} driver + * @param {?} normalizer + * @param {?} element + * @param {?} keyframes + * @param {?=} preStyles + * @param {?=} postStyles + * @return {?} + */ function normalizeKeyframes(driver, normalizer, element, keyframes, preStyles, postStyles) { if (preStyles === void 0) { preStyles = {}; } if (postStyles === void 0) { postStyles = {}; } - var errors = []; - var normalizedKeyframes = []; - var previousOffset = -1; - var previousKeyframe = null; + var /** @type {?} */ errors = []; + var /** @type {?} */ normalizedKeyframes = []; + var /** @type {?} */ previousOffset = -1; + var /** @type {?} */ previousKeyframe = null; keyframes.forEach(function (kf) { - var offset = kf['offset']; - var isSameOffset = offset == previousOffset; - var normalizedKeyframe = (isSameOffset && previousKeyframe) || {}; + var /** @type {?} */ offset = /** @type {?} */ (kf['offset']); + var /** @type {?} */ isSameOffset = offset == previousOffset; + var /** @type {?} */ normalizedKeyframe = (isSameOffset && previousKeyframe) || {}; Object.keys(kf).forEach(function (prop) { - var normalizedProp = prop; - var normalizedValue = kf[prop]; + var /** @type {?} */ normalizedProp = prop; + var /** @type {?} */ normalizedValue = kf[prop]; if (prop !== 'offset') { normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors); switch (normalizedValue) { @@ -95,11 +113,18 @@ function normalizeKeyframes(driver, normalizer, element, keyframes, preStyles, p previousOffset = offset; }); if (errors.length) { - var LINE_START = '\n - '; + var /** @type {?} */ LINE_START = '\n - '; throw new Error("Unable to animate due to the following errors:" + LINE_START + errors.join(LINE_START)); } return normalizedKeyframes; } +/** + * @param {?} player + * @param {?} eventName + * @param {?} event + * @param {?} callback + * @return {?} + */ function listenOnPlayer(player, eventName, event, callback) { switch (eventName) { case 'start': @@ -113,21 +138,42 @@ function listenOnPlayer(player, eventName, event, callback) { break; } } +/** + * @param {?} e + * @param {?=} phaseName + * @param {?=} totalTime + * @return {?} + */ function copyAnimationEvent(e, phaseName, totalTime) { - var event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime); - var data = e['_data']; + var /** @type {?} */ event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime); + var /** @type {?} */ data = (/** @type {?} */ (e))['_data']; if (data != null) { - event['_data'] = data; + (/** @type {?} */ (event))['_data'] = data; } return event; } +/** + * @param {?} element + * @param {?} triggerName + * @param {?} fromState + * @param {?} toState + * @param {?=} phaseName + * @param {?=} totalTime + * @return {?} + */ function makeAnimationEvent(element, triggerName, fromState, toState, phaseName, totalTime) { if (phaseName === void 0) { phaseName = ''; } if (totalTime === void 0) { totalTime = 0; } return { element: element, triggerName: triggerName, fromState: fromState, toState: toState, phaseName: phaseName, totalTime: totalTime }; } +/** + * @param {?} map + * @param {?} key + * @param {?} defaultValue + * @return {?} + */ function getOrSetAsInMap(map, key, defaultValue) { - var value; + var /** @type {?} */ value; if (map instanceof Map) { value = map.get(key); if (!value) { @@ -142,38 +188,44 @@ function getOrSetAsInMap(map, key, defaultValue) { } return value; } +/** + * @param {?} command + * @return {?} + */ function parseTimelineCommand(command) { - var separatorPos = command.indexOf(':'); - var id = command.substring(1, separatorPos); - var action = command.substr(separatorPos + 1); + var /** @type {?} */ separatorPos = command.indexOf(':'); + var /** @type {?} */ id = command.substring(1, separatorPos); + var /** @type {?} */ action = command.substr(separatorPos + 1); return [id, action]; } var _contains = function (elm1, elm2) { return false; }; -var _matches = function (element, selector) { return false; }; +var _matches = function (element, selector) { + return false; +}; var _query = function (element, selector, multi) { return []; }; if (typeof Element != 'undefined') { // this is well supported in all browsers - _contains = function (elm1, elm2) { return elm1.contains(elm2); }; + _contains = function (elm1, elm2) { return /** @type {?} */ (elm1.contains(elm2)); }; if (Element.prototype.matches) { _matches = function (element, selector) { return element.matches(selector); }; } else { - var proto = Element.prototype; - var fn_1 = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || + var /** @type {?} */ proto = /** @type {?} */ (Element.prototype); + var /** @type {?} */ fn_1 = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector; if (fn_1) { _matches = function (element, selector) { return fn_1.apply(element, [selector]); }; } } _query = function (element, selector, multi) { - var results = []; + var /** @type {?} */ results = []; if (multi) { results.push.apply(results, element.querySelectorAll(selector)); } else { - var elm = element.querySelector(selector); + var /** @type {?} */ elm = element.querySelector(selector); if (elm) { results.push(elm); } @@ -181,113 +233,241 @@ if (typeof Element != 'undefined') { return results; }; } +/** + * @param {?} prop + * @return {?} + */ +function containsVendorPrefix(prop) { + // Webkit is the only real popular vendor prefix nowadays + // cc: http://shouldiprefix.com/ + return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit +} +var _CACHED_BODY = null; +var _IS_WEBKIT = false; +/** + * @param {?} prop + * @return {?} + */ +function validateStyleProperty(prop) { + if (!_CACHED_BODY) { + _CACHED_BODY = getBodyNode() || {}; + _IS_WEBKIT = /** @type {?} */ ((_CACHED_BODY)).style ? ('WebkitAppearance' in /** @type {?} */ ((_CACHED_BODY)).style) : false; + } + var /** @type {?} */ result = true; + if (/** @type {?} */ ((_CACHED_BODY)).style && !containsVendorPrefix(prop)) { + result = prop in /** @type {?} */ ((_CACHED_BODY)).style; + if (!result && _IS_WEBKIT) { + var /** @type {?} */ camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.substr(1); + result = camelProp in /** @type {?} */ ((_CACHED_BODY)).style; + } + } + return result; +} +/** + * @return {?} + */ +function getBodyNode() { + if (typeof document != 'undefined') { + return document.body; + } + return null; +} var matchesElement = _matches; var containsElement = _contains; var invokeQuery = _query; + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ /** - * @experimental + * \@experimental */ -var NoopAnimationDriver = (function () { +var NoopAnimationDriver = /** @class */ (function () { function NoopAnimationDriver() { } - NoopAnimationDriver.prototype.matchesElement = function (element, selector) { + /** + * @param {?} prop + * @return {?} + */ + NoopAnimationDriver.prototype.validateStyleProperty = /** + * @param {?} prop + * @return {?} + */ + function (prop) { return validateStyleProperty(prop); }; + /** + * @param {?} element + * @param {?} selector + * @return {?} + */ + NoopAnimationDriver.prototype.matchesElement = /** + * @param {?} element + * @param {?} selector + * @return {?} + */ + function (element, selector) { return matchesElement(element, selector); }; - NoopAnimationDriver.prototype.containsElement = function (elm1, elm2) { return containsElement(elm1, elm2); }; - NoopAnimationDriver.prototype.query = function (element, selector, multi) { + /** + * @param {?} elm1 + * @param {?} elm2 + * @return {?} + */ + NoopAnimationDriver.prototype.containsElement = /** + * @param {?} elm1 + * @param {?} elm2 + * @return {?} + */ + function (elm1, elm2) { return containsElement(elm1, elm2); }; + /** + * @param {?} element + * @param {?} selector + * @param {?} multi + * @return {?} + */ + NoopAnimationDriver.prototype.query = /** + * @param {?} element + * @param {?} selector + * @param {?} multi + * @return {?} + */ + function (element, selector, multi) { return invokeQuery(element, selector, multi); }; - NoopAnimationDriver.prototype.computeStyle = function (element, prop, defaultValue) { + /** + * @param {?} element + * @param {?} prop + * @param {?=} defaultValue + * @return {?} + */ + NoopAnimationDriver.prototype.computeStyle = /** + * @param {?} element + * @param {?} prop + * @param {?=} defaultValue + * @return {?} + */ + function (element, prop, defaultValue) { return defaultValue || ''; }; - NoopAnimationDriver.prototype.animate = function (element, keyframes, duration, delay, easing, previousPlayers) { + /** + * @param {?} element + * @param {?} keyframes + * @param {?} duration + * @param {?} delay + * @param {?} easing + * @param {?=} previousPlayers + * @return {?} + */ + NoopAnimationDriver.prototype.animate = /** + * @param {?} element + * @param {?} keyframes + * @param {?} duration + * @param {?} delay + * @param {?} easing + * @param {?=} previousPlayers + * @return {?} + */ + function (element, keyframes, duration, delay, easing, previousPlayers) { if (previousPlayers === void 0) { previousPlayers = []; } return new _angular_animations.NoopAnimationPlayer(); }; return NoopAnimationDriver; }()); /** - * @experimental + * \@experimental + * @abstract */ -var AnimationDriver = (function () { +var AnimationDriver = /** @class */ (function () { function AnimationDriver() { } + AnimationDriver.NOOP = new NoopAnimationDriver(); return AnimationDriver; }()); -AnimationDriver.NOOP = new NoopAnimationDriver(); + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ var ONE_SECOND = 1000; var SUBSTITUTION_EXPR_START = '{{'; var SUBSTITUTION_EXPR_END = '}}'; var ENTER_CLASSNAME = 'ng-enter'; var LEAVE_CLASSNAME = 'ng-leave'; -var ENTER_SELECTOR = '.ng-enter'; -var LEAVE_SELECTOR = '.ng-leave'; + + var NG_TRIGGER_CLASSNAME = 'ng-trigger'; var NG_TRIGGER_SELECTOR = '.ng-trigger'; var NG_ANIMATING_CLASSNAME = 'ng-animating'; var NG_ANIMATING_SELECTOR = '.ng-animating'; +/** + * @param {?} value + * @return {?} + */ function resolveTimingValue(value) { if (typeof value == 'number') return value; - var matches = value.match(/^(-?[\.\d]+)(m?s)/); + var /** @type {?} */ matches = (/** @type {?} */ (value)).match(/^(-?[\.\d]+)(m?s)/); if (!matches || matches.length < 2) return 0; return _convertTimeValueToMS(parseFloat(matches[1]), matches[2]); } +/** + * @param {?} value + * @param {?} unit + * @return {?} + */ function _convertTimeValueToMS(value, unit) { switch (unit) { case 's': return value * ONE_SECOND; default: + // ms or something else return value; } } +/** + * @param {?} timings + * @param {?} errors + * @param {?=} allowNegativeValues + * @return {?} + */ function resolveTiming(timings, errors, allowNegativeValues) { - return timings.hasOwnProperty('duration') ? - timings : - parseTimeExpression(timings, errors, allowNegativeValues); + return timings.hasOwnProperty('duration') ? /** @type {?} */ (timings) : + parseTimeExpression(/** @type {?} */ (timings), errors, allowNegativeValues); } +/** + * @param {?} exp + * @param {?} errors + * @param {?=} allowNegativeValues + * @return {?} + */ function parseTimeExpression(exp, errors, allowNegativeValues) { - var regex = /^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i; - var duration; - var delay = 0; - var easing = ''; + var /** @type {?} */ regex = /^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i; + var /** @type {?} */ duration; + var /** @type {?} */ delay = 0; + var /** @type {?} */ easing = ''; if (typeof exp === 'string') { - var matches = exp.match(regex); + var /** @type {?} */ matches = exp.match(regex); if (matches === null) { errors.push("The provided timing value \"" + exp + "\" is invalid."); return { duration: 0, delay: 0, easing: '' }; } duration = _convertTimeValueToMS(parseFloat(matches[1]), matches[2]); - var delayMatch = matches[3]; + var /** @type {?} */ delayMatch = matches[3]; if (delayMatch != null) { delay = _convertTimeValueToMS(Math.floor(parseFloat(delayMatch)), matches[4]); } - var easingVal = matches[5]; + var /** @type {?} */ easingVal = matches[5]; if (easingVal) { easing = easingVal; } } else { - duration = exp; + duration = /** @type {?} */ (exp); } if (!allowNegativeValues) { - var containsErrors = false; - var startIndex = errors.length; + var /** @type {?} */ containsErrors = false; + var /** @type {?} */ startIndex = errors.length; if (duration < 0) { errors.push("Duration values below 0 are not allowed for this animation step."); containsErrors = true; @@ -302,13 +482,22 @@ function parseTimeExpression(exp, errors, allowNegativeValues) { } return { duration: duration, delay: delay, easing: easing }; } +/** + * @param {?} obj + * @param {?=} destination + * @return {?} + */ function copyObj(obj, destination) { if (destination === void 0) { destination = {}; } Object.keys(obj).forEach(function (prop) { destination[prop] = obj[prop]; }); return destination; } +/** + * @param {?} styles + * @return {?} + */ function normalizeStyles(styles) { - var normalizedStyles = {}; + var /** @type {?} */ normalizedStyles = {}; if (Array.isArray(styles)) { styles.forEach(function (data) { return copyStyles(data, false, normalizedStyles); }); } @@ -317,13 +506,19 @@ function normalizeStyles(styles) { } return normalizedStyles; } +/** + * @param {?} styles + * @param {?} readPrototype + * @param {?=} destination + * @return {?} + */ function copyStyles(styles, readPrototype, destination) { if (destination === void 0) { destination = {}; } if (readPrototype) { // we make use of a for-in loop so that the // prototypically inherited properties are // revealed from the backFill map - for (var prop in styles) { + for (var /** @type {?} */ prop in styles) { destination[prop] = styles[prop]; } } @@ -332,33 +527,53 @@ function copyStyles(styles, readPrototype, destination) { } return destination; } +/** + * @param {?} element + * @param {?} styles + * @return {?} + */ function setStyles(element, styles) { if (element['style']) { Object.keys(styles).forEach(function (prop) { - var camelProp = dashCaseToCamelCase(prop); + var /** @type {?} */ camelProp = dashCaseToCamelCase(prop); element.style[camelProp] = styles[prop]; }); } } +/** + * @param {?} element + * @param {?} styles + * @return {?} + */ function eraseStyles(element, styles) { if (element['style']) { Object.keys(styles).forEach(function (prop) { - var camelProp = dashCaseToCamelCase(prop); + var /** @type {?} */ camelProp = dashCaseToCamelCase(prop); element.style[camelProp] = ''; }); } } +/** + * @param {?} steps + * @return {?} + */ function normalizeAnimationEntry(steps) { if (Array.isArray(steps)) { if (steps.length == 1) return steps[0]; return _angular_animations.sequence(steps); } - return steps; + return /** @type {?} */ (steps); } +/** + * @param {?} value + * @param {?} options + * @param {?} errors + * @return {?} + */ function validateStyleParams(value, options, errors) { - var params = options.params || {}; - var matches = extractStyleParams(value); + var /** @type {?} */ params = options.params || {}; + var /** @type {?} */ matches = extractStyleParams(value); if (matches.length) { matches.forEach(function (varName) { if (!params.hasOwnProperty(varName)) { @@ -368,22 +583,32 @@ function validateStyleParams(value, options, errors) { } } var PARAM_REGEX = new RegExp(SUBSTITUTION_EXPR_START + "\\s*(.+?)\\s*" + SUBSTITUTION_EXPR_END, 'g'); +/** + * @param {?} value + * @return {?} + */ function extractStyleParams(value) { - var params = []; + var /** @type {?} */ params = []; if (typeof value === 'string') { - var val = value.toString(); - var match = void 0; + var /** @type {?} */ val = value.toString(); + var /** @type {?} */ match = void 0; while (match = PARAM_REGEX.exec(val)) { - params.push(match[1]); + params.push(/** @type {?} */ (match[1])); } PARAM_REGEX.lastIndex = 0; } return params; } +/** + * @param {?} value + * @param {?} params + * @param {?} errors + * @return {?} + */ function interpolateParams(value, params, errors) { - var original = value.toString(); - var str = original.replace(PARAM_REGEX, function (_, varName) { - var localVal = params[varName]; + var /** @type {?} */ original = value.toString(); + var /** @type {?} */ str = original.replace(PARAM_REGEX, function (_, varName) { + var /** @type {?} */ localVal = params[varName]; // this means that the value was never overidden by the data passed in by the user if (!params.hasOwnProperty(varName)) { errors.push("Please provide a value for the animation param " + varName); @@ -394,16 +619,30 @@ function interpolateParams(value, params, errors) { // we do this to assert that numeric values stay as they are return str == original ? value : str; } +/** + * @param {?} iterator + * @return {?} + */ function iteratorToArray(iterator) { - var arr = []; - var item = iterator.next(); + var /** @type {?} */ arr = []; + var /** @type {?} */ item = iterator.next(); while (!item.done) { arr.push(item.value); item = iterator.next(); } return arr; } +/** + * @param {?} source + * @param {?} destination + * @return {?} + */ + var DASH_CASE_REGEXP = /-+([a-z0-9])/g; +/** + * @param {?} input + * @return {?} + */ function dashCaseToCamelCase(input) { return input.replace(DASH_CASE_REGEXP, function () { var m = []; @@ -413,9 +652,20 @@ function dashCaseToCamelCase(input) { return m[1].toUpperCase(); }); } +/** + * @param {?} duration + * @param {?} delay + * @return {?} + */ function allowPreviousPlayerStylesMerge(duration, delay) { return duration === 0 || delay === 0; } +/** + * @param {?} visitor + * @param {?} node + * @param {?} context + * @return {?} + */ function visitDslNode(visitor, node, context) { switch (node.type) { case 7 /* Trigger */: @@ -448,6 +698,11 @@ function visitDslNode(visitor, node, context) { throw new Error("Unable to resolve animation metadata node #" + node.type); } } + +/** + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ /** * @license * Copyright Google Inc. All Rights Reserved. @@ -464,7 +719,7 @@ var ANY_STATE = '*'; function parseTransitionExpr(transitionValue, errors) { var /** @type {?} */ expressions = []; if (typeof transitionValue == 'string') { - ((transitionValue)) + (/** @type {?} */ (transitionValue)) .split(/\s*,\s*/) .forEach(function (str) { return parseInnerTransitionStr(str, expressions, errors); }); } @@ -481,7 +736,12 @@ function parseTransitionExpr(transitionValue, errors) { */ function parseInnerTransitionStr(eventStr, expressions, errors) { if (eventStr[0] == ':') { - eventStr = parseAnimationAlias(eventStr, errors); + var /** @type {?} */ result = parseAnimationAlias(eventStr, errors); + if (typeof result == 'function') { + expressions.push(result); + return; + } + eventStr = /** @type {?} */ (result); } var /** @type {?} */ match = eventStr.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/); if (match == null || match.length < 4) { @@ -508,17 +768,21 @@ function parseAnimationAlias(alias, errors) { return 'void => *'; case ':leave': return '* => void'; + case ':increment': + return function (fromState, toState) { return parseFloat(toState) > parseFloat(fromState); }; + case ':decrement': + return function (fromState, toState) { return parseFloat(toState) < parseFloat(fromState); }; default: errors.push("The transition alias value \"" + alias + "\" is not supported"); return '* => *'; } } -var TRUE_BOOLEAN_VALUES = new Set(); -TRUE_BOOLEAN_VALUES.add('true'); -TRUE_BOOLEAN_VALUES.add('1'); -var FALSE_BOOLEAN_VALUES = new Set(); -FALSE_BOOLEAN_VALUES.add('false'); -FALSE_BOOLEAN_VALUES.add('0'); +// DO NOT REFACTOR ... keep the follow set instantiations +// with the values intact (closure compiler for some reason +// removes follow-up lines that add the values outside of +// the constructor... +var TRUE_BOOLEAN_VALUES = new Set(['true', '1']); +var FALSE_BOOLEAN_VALUES = new Set(['false', '0']); /** * @param {?} lhs * @param {?} rhs @@ -539,46 +803,51 @@ function makeLambdaFromStates(lhs, rhs) { return lhsMatch && rhsMatch; }; } + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ var SELF_TOKEN = ':self'; var SELF_TOKEN_REGEX = new RegExp("s*" + SELF_TOKEN + "s*,?", 'g'); /** + * @param {?} driver * @param {?} metadata * @param {?} errors * @return {?} */ -function buildAnimationAst(metadata, errors) { - return new AnimationAstBuilderVisitor().build(metadata, errors); +function buildAnimationAst(driver, metadata, errors) { + return new AnimationAstBuilderVisitor(driver).build(metadata, errors); } -var LEAVE_TOKEN = ':leave'; -var LEAVE_TOKEN_REGEX = new RegExp(LEAVE_TOKEN, 'g'); -var ENTER_TOKEN = ':enter'; -var ENTER_TOKEN_REGEX = new RegExp(ENTER_TOKEN, 'g'); var ROOT_SELECTOR = ''; -var AnimationAstBuilderVisitor = (function () { - function AnimationAstBuilderVisitor() { +var AnimationAstBuilderVisitor = /** @class */ (function () { + function AnimationAstBuilderVisitor(_driver) { + this._driver = _driver; } /** * @param {?} metadata * @param {?} errors * @return {?} */ - AnimationAstBuilderVisitor.prototype.build = function (metadata, errors) { + AnimationAstBuilderVisitor.prototype.build = /** + * @param {?} metadata + * @param {?} errors + * @return {?} + */ + function (metadata, errors) { var /** @type {?} */ context = new AnimationAstBuilderContext(errors); this._resetContextStyleTimingState(context); - return (visitDslNode(this, normalizeAnimationEntry(metadata), context)); + return /** @type {?} */ (visitDslNode(this, normalizeAnimationEntry(metadata), context)); }; /** * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype._resetContextStyleTimingState = function (context) { + AnimationAstBuilderVisitor.prototype._resetContextStyleTimingState = /** + * @param {?} context + * @return {?} + */ + function (context) { context.currentQuerySelector = ROOT_SELECTOR; context.collectedStyles = {}; context.collectedStyles[ROOT_SELECTOR] = {}; @@ -589,22 +858,30 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitTrigger = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitTrigger = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var _this = this; var /** @type {?} */ queryCount = context.queryCount = 0; var /** @type {?} */ depCount = context.depCount = 0; var /** @type {?} */ states = []; var /** @type {?} */ transitions = []; + if (metadata.name.charAt(0) == '@') { + context.errors.push('animation triggers cannot be prefixed with an `@` sign (e.g. trigger(\'@foo\', [...]))'); + } metadata.definitions.forEach(function (def) { _this._resetContextStyleTimingState(context); if (def.type == 0 /* State */) { - var /** @type {?} */ stateDef_1 = (def); - var /** @type {?} */ name = stateDef_1.name; - name.split(/\s*,\s*/).forEach(function (n) { + var /** @type {?} */ stateDef_1 = /** @type {?} */ (def); + var /** @type {?} */ name_1 = stateDef_1.name; + name_1.split(/\s*,\s*/).forEach(function (n) { stateDef_1.name = n; states.push(_this.visitState(stateDef_1, context)); }); - stateDef_1.name = name; + stateDef_1.name = name_1; } else if (def.type == 1 /* Transition */) { var /** @type {?} */ transition = _this.visitTransition(/** @type {?} */ (def), context); @@ -627,7 +904,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitState = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitState = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var /** @type {?} */ styleAst = this.visitStyle(metadata.styles, context); var /** @type {?} */ astParams = (metadata.options && metadata.options.params) || null; if (styleAst.containsDynamicStyles) { @@ -635,7 +917,7 @@ var AnimationAstBuilderVisitor = (function () { var /** @type {?} */ params_1 = astParams || {}; styleAst.styles.forEach(function (value) { if (isObject(value)) { - var /** @type {?} */ stylesObj_1 = (value); + var /** @type {?} */ stylesObj_1 = /** @type {?} */ (value); Object.keys(stylesObj_1).forEach(function (prop) { extractStyleParams(stylesObj_1[prop]).forEach(function (sub) { if (!params_1.hasOwnProperty(sub)) { @@ -662,7 +944,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitTransition = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitTransition = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { context.queryCount = 0; context.depCount = 0; var /** @type {?} */ animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context); @@ -681,7 +968,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitSequence = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitSequence = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var _this = this; return { type: 2 /* Sequence */, @@ -694,7 +986,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitGroup = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitGroup = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var _this = this; var /** @type {?} */ currentTime = context.currentTime; var /** @type {?} */ furthestTime = 0; @@ -716,7 +1013,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitAnimate = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitAnimate = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var /** @type {?} */ timingAst = constructTimingAst(metadata.timings, context.errors); context.currentAnimateTimings = timingAst; var /** @type {?} */ styleAst; @@ -725,7 +1027,7 @@ var AnimationAstBuilderVisitor = (function () { styleAst = this.visitKeyframes(/** @type {?} */ (styleMetadata), context); } else { - var /** @type {?} */ styleMetadata_1 = (metadata.styles); + var /** @type {?} */ styleMetadata_1 = /** @type {?} */ (metadata.styles); var /** @type {?} */ isEmpty = false; if (!styleMetadata_1) { isEmpty = true; @@ -753,7 +1055,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitStyle = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitStyle = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var /** @type {?} */ ast = this._makeStyleAst(metadata, context); this._validateStyleAst(ast, context); return ast; @@ -763,10 +1070,15 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype._makeStyleAst = function (metadata, context) { + AnimationAstBuilderVisitor.prototype._makeStyleAst = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var /** @type {?} */ styles = []; if (Array.isArray(metadata.styles)) { - ((metadata.styles)).forEach(function (styleTuple) { + (/** @type {?} */ (metadata.styles)).forEach(function (styleTuple) { if (typeof styleTuple == 'string') { if (styleTuple == _angular_animations.AUTO_STYLE) { styles.push(/** @type {?} */ (styleTuple)); @@ -787,10 +1099,10 @@ var AnimationAstBuilderVisitor = (function () { var /** @type {?} */ collectedEasing = null; styles.forEach(function (styleData) { if (isObject(styleData)) { - var /** @type {?} */ styleMap = (styleData); + var /** @type {?} */ styleMap = /** @type {?} */ (styleData); var /** @type {?} */ easing = styleMap['easing']; if (easing) { - collectedEasing = (easing); + collectedEasing = /** @type {?} */ (easing); delete styleMap['easing']; } if (!containsDynamicStyles) { @@ -817,7 +1129,13 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype._validateStyleAst = function (ast, context) { + AnimationAstBuilderVisitor.prototype._validateStyleAst = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + var _this = this; var /** @type {?} */ timings = context.currentAnimateTimings; var /** @type {?} */ endTime = context.currentTime; var /** @type {?} */ startTime = context.currentTime; @@ -828,7 +1146,11 @@ var AnimationAstBuilderVisitor = (function () { if (typeof tuple == 'string') return; Object.keys(tuple).forEach(function (prop) { - var /** @type {?} */ collectedStyles = context.collectedStyles[((context.currentQuerySelector))]; + if (!_this._driver.validateStyleProperty(prop)) { + context.errors.push("The provided animation property \"" + prop + "\" is not a supported CSS property for animations"); + return; + } + var /** @type {?} */ collectedStyles = context.collectedStyles[/** @type {?} */ ((context.currentQuerySelector))]; var /** @type {?} */ collectedEntry = collectedStyles[prop]; var /** @type {?} */ updateCollectedStyle = true; if (collectedEntry) { @@ -856,7 +1178,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitKeyframes = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitKeyframes = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { var _this = this; var /** @type {?} */ ast = { type: 5 /* Keyframes */, styles: [], options: null }; if (!context.currentAnimateTimings) { @@ -899,7 +1226,7 @@ var AnimationAstBuilderVisitor = (function () { } var /** @type {?} */ limit = length - 1; var /** @type {?} */ currentTime = context.currentTime; - var /** @type {?} */ currentAnimateTimings = ((context.currentAnimateTimings)); + var /** @type {?} */ currentAnimateTimings = /** @type {?} */ ((context.currentAnimateTimings)); var /** @type {?} */ animateDuration = currentAnimateTimings.duration; keyframes.forEach(function (kf, i) { var /** @type {?} */ offset = generatedOffset > 0 ? (i == limit ? 1 : (generatedOffset * i)) : offsets[i]; @@ -917,7 +1244,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitReference = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitReference = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { return { type: 8 /* Reference */, animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context), @@ -929,7 +1261,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitAnimateChild = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitAnimateChild = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { context.depCount++; return { type: 9 /* AnimateChild */, @@ -941,7 +1278,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitAnimateRef = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitAnimateRef = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { return { type: 10 /* AnimateRef */, animation: this.visitReference(metadata.animation, context), @@ -953,9 +1295,14 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitQuery = function (metadata, context) { - var /** @type {?} */ parentSelector = ((context.currentQuerySelector)); - var /** @type {?} */ options = ((metadata.options || {})); + AnimationAstBuilderVisitor.prototype.visitQuery = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + var /** @type {?} */ parentSelector = /** @type {?} */ ((context.currentQuerySelector)); + var /** @type {?} */ options = /** @type {?} */ ((metadata.options || {})); context.queryCount++; context.currentQuery = metadata; var _a = normalizeSelector(metadata.selector), selector = _a[0], includeSelf = _a[1]; @@ -979,7 +1326,12 @@ var AnimationAstBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationAstBuilderVisitor.prototype.visitStagger = function (metadata, context) { + AnimationAstBuilderVisitor.prototype.visitStagger = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { if (!context.currentQuery) { context.errors.push("stagger() can only be used inside of query()"); } @@ -1003,9 +1355,8 @@ function normalizeSelector(selector) { if (hasAmpersand) { selector = selector.replace(SELF_TOKEN_REGEX, ''); } - selector = selector.replace(ENTER_TOKEN_REGEX, ENTER_SELECTOR) - .replace(LEAVE_TOKEN_REGEX, LEAVE_SELECTOR) - .replace(/@\*/g, NG_TRIGGER_SELECTOR) + // the :enter and :leave selectors are filled in at runtime during timeline building + selector = selector.replace(/@\*/g, NG_TRIGGER_SELECTOR) .replace(/@\w+/g, function (match) { return NG_TRIGGER_SELECTOR + '-' + match.substr(1); }) .replace(/:animating/g, NG_ANIMATING_SELECTOR); return [selector, hasAmpersand]; @@ -1017,10 +1368,7 @@ function normalizeSelector(selector) { function normalizeParams(obj) { return obj ? copyObj(obj) : null; } -var AnimationAstBuilderContext = (function () { - /** - * @param {?} errors - */ +var AnimationAstBuilderContext = /** @class */ (function () { function AnimationAstBuilderContext(errors) { this.errors = errors; this.queryCount = 0; @@ -1046,14 +1394,14 @@ function consumeOffset(styles) { if (Array.isArray(styles)) { styles.forEach(function (styleTuple) { if (isObject(styleTuple) && styleTuple.hasOwnProperty('offset')) { - var /** @type {?} */ obj = (styleTuple); + var /** @type {?} */ obj = /** @type {?} */ (styleTuple); offset = parseFloat(/** @type {?} */ (obj['offset'])); delete obj['offset']; } }); } else if (isObject(styles) && styles.hasOwnProperty('offset')) { - var /** @type {?} */ obj = (styles); + var /** @type {?} */ obj = /** @type {?} */ (styles); offset = parseFloat(/** @type {?} */ (obj['offset'])); delete obj['offset']; } @@ -1074,19 +1422,19 @@ function isObject(value) { function constructTimingAst(value, errors) { var /** @type {?} */ timings = null; if (value.hasOwnProperty('duration')) { - timings = (value); + timings = /** @type {?} */ (value); } else if (typeof value == 'number') { var /** @type {?} */ duration = resolveTiming(/** @type {?} */ (value), errors).duration; return makeTimingAst(/** @type {?} */ (duration), 0, ''); } - var /** @type {?} */ strValue = (value); + var /** @type {?} */ strValue = /** @type {?} */ (value); var /** @type {?} */ isDynamic = strValue.split(/\s+/).some(function (v) { return v.charAt(0) == '{' && v.charAt(1) == '{'; }); if (isDynamic) { - var /** @type {?} */ ast = (makeTimingAst(0, 0, '')); + var /** @type {?} */ ast = /** @type {?} */ (makeTimingAst(0, 0, '')); ast.dynamic = true; ast.strValue = strValue; - return (ast); + return /** @type {?} */ (ast); } timings = timings || resolveTiming(strValue, errors); return makeTimingAst(timings.duration, timings.delay, timings.easing); @@ -1099,7 +1447,7 @@ function normalizeAnimationOptions(options) { if (options) { options = copyObj(options); if (options['params']) { - options['params'] = ((normalizeParams(options['params']))); + options['params'] = /** @type {?} */ ((normalizeParams(options['params']))); } } else { @@ -1116,14 +1464,16 @@ function normalizeAnimationOptions(options) { function makeTimingAst(duration, delay, easing) { return { duration: duration, delay: delay, easing: easing }; } + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ /** + * @record + */ + +/** * @param {?} element * @param {?} keyframes * @param {?} preStyleProps @@ -1148,14 +1498,12 @@ function createTimelineInstruction(element, keyframes, preStyleProps, postStyleP totalTime: duration + delay, easing: easing, subTimeline: subTimeline }; } + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ -var ElementInstructionMap = (function () { +var ElementInstructionMap = /** @class */ (function () { function ElementInstructionMap() { this._map = new Map(); } @@ -1163,7 +1511,11 @@ var ElementInstructionMap = (function () { * @param {?} element * @return {?} */ - ElementInstructionMap.prototype.consume = function (element) { + ElementInstructionMap.prototype.consume = /** + * @param {?} element + * @return {?} + */ + function (element) { var /** @type {?} */ instructions = this._map.get(element); if (instructions) { this._map.delete(element); @@ -1178,7 +1530,12 @@ var ElementInstructionMap = (function () { * @param {?} instructions * @return {?} */ - ElementInstructionMap.prototype.append = function (element, instructions) { + ElementInstructionMap.prototype.append = /** + * @param {?} element + * @param {?} instructions + * @return {?} + */ + function (element, instructions) { var /** @type {?} */ existingInstructions = this._map.get(element); if (!existingInstructions) { this._map.set(element, existingInstructions = []); @@ -1189,25 +1546,36 @@ var ElementInstructionMap = (function () { * @param {?} element * @return {?} */ - ElementInstructionMap.prototype.has = function (element) { return this._map.has(element); }; + ElementInstructionMap.prototype.has = /** + * @param {?} element + * @return {?} + */ + function (element) { return this._map.has(element); }; /** * @return {?} */ - ElementInstructionMap.prototype.clear = function () { this._map.clear(); }; + ElementInstructionMap.prototype.clear = /** + * @return {?} + */ + function () { this._map.clear(); }; return ElementInstructionMap; }()); + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ var ONE_FRAME_IN_MILLISECONDS = 1; +var ENTER_TOKEN = ':enter'; +var ENTER_TOKEN_REGEX = new RegExp(ENTER_TOKEN, 'g'); +var LEAVE_TOKEN = ':leave'; +var LEAVE_TOKEN_REGEX = new RegExp(LEAVE_TOKEN, 'g'); /** * @param {?} driver * @param {?} rootElement * @param {?} ast + * @param {?} enterClassName + * @param {?} leaveClassName * @param {?=} startingStyles * @param {?=} finalStyles * @param {?=} options @@ -1215,19 +1583,34 @@ var ONE_FRAME_IN_MILLISECONDS = 1; * @param {?=} errors * @return {?} */ -function buildAnimationTimelines(driver, rootElement, ast, startingStyles, finalStyles, options, subInstructions, errors) { +function buildAnimationTimelines(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors) { if (startingStyles === void 0) { startingStyles = {}; } if (finalStyles === void 0) { finalStyles = {}; } if (errors === void 0) { errors = []; } - return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, startingStyles, finalStyles, options, subInstructions, errors); + return new AnimationTimelineBuilderVisitor().buildKeyframes(driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors); } -var AnimationTimelineBuilderVisitor = (function () { +var AnimationTimelineBuilderVisitor = /** @class */ (function () { function AnimationTimelineBuilderVisitor() { } /** * @param {?} driver * @param {?} rootElement * @param {?} ast + * @param {?} enterClassName + * @param {?} leaveClassName + * @param {?} startingStyles + * @param {?} finalStyles + * @param {?} options + * @param {?=} subInstructions + * @param {?=} errors + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.buildKeyframes = /** + * @param {?} driver + * @param {?} rootElement + * @param {?} ast + * @param {?} enterClassName + * @param {?} leaveClassName * @param {?} startingStyles * @param {?} finalStyles * @param {?} options @@ -1235,10 +1618,10 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?=} errors * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.buildKeyframes = function (driver, rootElement, ast, startingStyles, finalStyles, options, subInstructions, errors) { + function (driver, rootElement, ast, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors) { if (errors === void 0) { errors = []; } subInstructions = subInstructions || new ElementInstructionMap(); - var /** @type {?} */ context = new AnimationTimelineContext(driver, rootElement, subInstructions, errors, []); + var /** @type {?} */ context = new AnimationTimelineContext(driver, rootElement, subInstructions, enterClassName, leaveClassName, errors, []); context.options = options; context.currentTimeline.setStyles([startingStyles], null, context.errors, options); visitDslNode(this, ast, context); @@ -1258,7 +1641,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitTrigger = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitTrigger = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { // these values are not visited in this AST }; /** @@ -1266,7 +1654,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitState = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitState = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { // these values are not visited in this AST }; /** @@ -1274,7 +1667,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitTransition = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitTransition = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { // these values are not visited in this AST }; /** @@ -1282,7 +1680,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitAnimateChild = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitAnimateChild = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var /** @type {?} */ elementInstructions = context.subInstructions.consume(context.element); if (elementInstructions) { var /** @type {?} */ innerContext = context.createSubContext(ast.options); @@ -1301,7 +1704,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitAnimateRef = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitAnimateRef = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var /** @type {?} */ innerContext = context.createSubContext(ast.options); innerContext.transformIntoNewTimeline(); this.visitReference(ast.animation, innerContext); @@ -1314,7 +1722,13 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} options * @return {?} */ - AnimationTimelineBuilderVisitor.prototype._visitSubInstructions = function (instructions, context, options) { + AnimationTimelineBuilderVisitor.prototype._visitSubInstructions = /** + * @param {?} instructions + * @param {?} context + * @param {?} options + * @return {?} + */ + function (instructions, context, options) { var /** @type {?} */ startTime = context.currentTimeline.currentTime; var /** @type {?} */ furthestTime = startTime; // this is a special-case for when a user wants to skip a sub @@ -1335,7 +1749,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitReference = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitReference = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { context.updateOptions(ast.options, true); visitDslNode(this, ast.animation, context); context.previousNode = ast; @@ -1345,7 +1764,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitSequence = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitSequence = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var _this = this; var /** @type {?} */ subContextCount = context.subContextCount; var /** @type {?} */ ctx = context; @@ -1380,7 +1804,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitGroup = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitGroup = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var _this = this; var /** @type {?} */ innerTimelines = []; var /** @type {?} */ furthestTime = context.currentTimeline.currentTime; @@ -1406,9 +1835,14 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype._visitTiming = function (ast, context) { - if (((ast)).dynamic) { - var /** @type {?} */ strValue = ((ast)).strValue; + AnimationTimelineBuilderVisitor.prototype._visitTiming = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + if ((/** @type {?} */ (ast)).dynamic) { + var /** @type {?} */ strValue = (/** @type {?} */ (ast)).strValue; var /** @type {?} */ timingValue = context.params ? interpolateParams(strValue, context.params, context.errors) : strValue; return resolveTiming(timingValue, context.errors); } @@ -1421,7 +1855,12 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitAnimate = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitAnimate = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var /** @type {?} */ timings = context.currentAnimateTimings = this._visitTiming(ast.timings, context); var /** @type {?} */ timeline = context.currentTimeline; if (timings.delay) { @@ -1445,9 +1884,14 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitStyle = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitStyle = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var /** @type {?} */ timeline = context.currentTimeline; - var /** @type {?} */ timings = ((context.currentAnimateTimings)); + var /** @type {?} */ timings = /** @type {?} */ ((context.currentAnimateTimings)); // this is a special case for when a style() call // directly follows an animate() call (but not inside of an animate() call) if (!timings && timeline.getCurrentStyleProperties().length) { @@ -1467,9 +1911,14 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitKeyframes = function (ast, context) { - var /** @type {?} */ currentAnimateTimings = ((context.currentAnimateTimings)); - var /** @type {?} */ startTime = (((context.currentTimeline))).duration; + AnimationTimelineBuilderVisitor.prototype.visitKeyframes = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + var /** @type {?} */ currentAnimateTimings = /** @type {?} */ ((context.currentAnimateTimings)); + var /** @type {?} */ startTime = (/** @type {?} */ ((context.currentTimeline))).duration; var /** @type {?} */ duration = currentAnimateTimings.duration; var /** @type {?} */ innerContext = context.createSubContext(); var /** @type {?} */ innerTimeline = innerContext.currentTimeline; @@ -1493,12 +1942,17 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitQuery = function (ast, context) { + AnimationTimelineBuilderVisitor.prototype.visitQuery = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { var _this = this; // in the event that the first step before this is a style step we need // to ensure the styles are applied before the children are animated var /** @type {?} */ startTime = context.currentTimeline.currentTime; - var /** @type {?} */ options = ((ast.options || {})); + var /** @type {?} */ options = /** @type {?} */ ((ast.options || {})); var /** @type {?} */ delay = options.delay ? resolveTimingValue(options.delay) : 0; if (delay && (context.previousNode.type === 6 /* Style */ || (startTime == 0 && context.currentTimeline.getCurrentStyleProperties().length))) { @@ -1540,8 +1994,13 @@ var AnimationTimelineBuilderVisitor = (function () { * @param {?} context * @return {?} */ - AnimationTimelineBuilderVisitor.prototype.visitStagger = function (ast, context) { - var /** @type {?} */ parentContext = ((context.parentContext)); + AnimationTimelineBuilderVisitor.prototype.visitStagger = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + var /** @type {?} */ parentContext = /** @type {?} */ ((context.parentContext)); var /** @type {?} */ tl = context.currentTimeline; var /** @type {?} */ timings = ast.timings; var /** @type {?} */ duration = Math.abs(timings.duration); @@ -1572,20 +2031,14 @@ var AnimationTimelineBuilderVisitor = (function () { }; return AnimationTimelineBuilderVisitor; }()); -var DEFAULT_NOOP_PREVIOUS_NODE = ({}); -var AnimationTimelineContext = (function () { - /** - * @param {?} _driver - * @param {?} element - * @param {?} subInstructions - * @param {?} errors - * @param {?} timelines - * @param {?=} initialTimeline - */ - function AnimationTimelineContext(_driver, element, subInstructions, errors, timelines, initialTimeline) { +var DEFAULT_NOOP_PREVIOUS_NODE = /** @type {?} */ ({}); +var AnimationTimelineContext = /** @class */ (function () { + function AnimationTimelineContext(_driver, element, subInstructions, _enterClassName, _leaveClassName, errors, timelines, initialTimeline) { this._driver = _driver; this.element = element; this.subInstructions = subInstructions; + this._enterClassName = _enterClassName; + this._leaveClassName = _leaveClassName; this.errors = errors; this.timelines = timelines; this.parentContext = null; @@ -1596,14 +2049,14 @@ var AnimationTimelineContext = (function () { this.currentQueryIndex = 0; this.currentQueryTotal = 0; this.currentStaggerTime = 0; - this.currentTimeline = initialTimeline || new TimelineBuilder(element, 0); + this.currentTimeline = initialTimeline || new TimelineBuilder(this._driver, element, 0); timelines.push(this.currentTimeline); } Object.defineProperty(AnimationTimelineContext.prototype, "params", { - /** + get: /** * @return {?} */ - get: function () { return this.options.params; }, + function () { return this.options.params; }, enumerable: true, configurable: true }); @@ -1612,22 +2065,27 @@ var AnimationTimelineContext = (function () { * @param {?=} skipIfExists * @return {?} */ - AnimationTimelineContext.prototype.updateOptions = function (options, skipIfExists) { + AnimationTimelineContext.prototype.updateOptions = /** + * @param {?} options + * @param {?=} skipIfExists + * @return {?} + */ + function (options, skipIfExists) { var _this = this; if (!options) return; - var /** @type {?} */ newOptions = (options); + var /** @type {?} */ newOptions = /** @type {?} */ (options); var /** @type {?} */ optionsToUpdate = this.options; // NOTE: this will get patched up when other animation methods support duration overrides if (newOptions.duration != null) { - ((optionsToUpdate)).duration = resolveTimingValue(newOptions.duration); + (/** @type {?} */ (optionsToUpdate)).duration = resolveTimingValue(newOptions.duration); } if (newOptions.delay != null) { optionsToUpdate.delay = resolveTimingValue(newOptions.delay); } var /** @type {?} */ newParams = newOptions.params; if (newParams) { - var /** @type {?} */ paramsToUpdate_1 = ((optionsToUpdate.params)); + var /** @type {?} */ paramsToUpdate_1 = /** @type {?} */ ((optionsToUpdate.params)); if (!paramsToUpdate_1) { paramsToUpdate_1 = this.options.params = {}; } @@ -1641,13 +2099,16 @@ var AnimationTimelineContext = (function () { /** * @return {?} */ - AnimationTimelineContext.prototype._copyOptions = function () { + AnimationTimelineContext.prototype._copyOptions = /** + * @return {?} + */ + function () { var /** @type {?} */ options = {}; if (this.options) { var /** @type {?} */ oldParams_1 = this.options.params; if (oldParams_1) { - var /** @type {?} */ params_2 = options['params'] = {}; - Object.keys(oldParams_1).forEach(function (name) { params_2[name] = oldParams_1[name]; }); + var /** @type {?} */ params_1 = options['params'] = {}; + Object.keys(oldParams_1).forEach(function (name) { params_1[name] = oldParams_1[name]; }); } } return options; @@ -1658,10 +2119,16 @@ var AnimationTimelineContext = (function () { * @param {?=} newTime * @return {?} */ - AnimationTimelineContext.prototype.createSubContext = function (options, element, newTime) { + AnimationTimelineContext.prototype.createSubContext = /** + * @param {?=} options + * @param {?=} element + * @param {?=} newTime + * @return {?} + */ + function (options, element, newTime) { if (options === void 0) { options = null; } var /** @type {?} */ target = element || this.element; - var /** @type {?} */ context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0)); + var /** @type {?} */ context = new AnimationTimelineContext(this._driver, target, this.subInstructions, this._enterClassName, this._leaveClassName, this.errors, this.timelines, this.currentTimeline.fork(target, newTime || 0)); context.previousNode = this.previousNode; context.currentAnimateTimings = this.currentAnimateTimings; context.options = this._copyOptions(); @@ -1676,7 +2143,11 @@ var AnimationTimelineContext = (function () { * @param {?=} newTime * @return {?} */ - AnimationTimelineContext.prototype.transformIntoNewTimeline = function (newTime) { + AnimationTimelineContext.prototype.transformIntoNewTimeline = /** + * @param {?=} newTime + * @return {?} + */ + function (newTime) { this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE; this.currentTimeline = this.currentTimeline.fork(this.element, newTime); this.timelines.push(this.currentTimeline); @@ -1688,13 +2159,19 @@ var AnimationTimelineContext = (function () { * @param {?} delay * @return {?} */ - AnimationTimelineContext.prototype.appendInstructionToTimeline = function (instruction, duration, delay) { + AnimationTimelineContext.prototype.appendInstructionToTimeline = /** + * @param {?} instruction + * @param {?} duration + * @param {?} delay + * @return {?} + */ + function (instruction, duration, delay) { var /** @type {?} */ updatedTimings = { duration: duration != null ? duration : instruction.duration, delay: this.currentTimeline.currentTime + (delay != null ? delay : 0) + instruction.delay, easing: '' }; - var /** @type {?} */ builder = new SubTimelineBuilder(instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe); + var /** @type {?} */ builder = new SubTimelineBuilder(this._driver, instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe); this.timelines.push(builder); return updatedTimings; }; @@ -1702,14 +2179,22 @@ var AnimationTimelineContext = (function () { * @param {?} time * @return {?} */ - AnimationTimelineContext.prototype.incrementTime = function (time) { + AnimationTimelineContext.prototype.incrementTime = /** + * @param {?} time + * @return {?} + */ + function (time) { this.currentTimeline.forwardTime(this.currentTimeline.duration + time); }; /** * @param {?} delay * @return {?} */ - AnimationTimelineContext.prototype.delayNextStep = function (delay) { + AnimationTimelineContext.prototype.delayNextStep = /** + * @param {?} delay + * @return {?} + */ + function (delay) { // negative delays are not yet supported if (delay > 0) { this.currentTimeline.delayNextStep(delay); @@ -1724,16 +2209,29 @@ var AnimationTimelineContext = (function () { * @param {?} errors * @return {?} */ - AnimationTimelineContext.prototype.invokeQuery = function (selector, originalSelector, limit, includeSelf, optional, errors) { + AnimationTimelineContext.prototype.invokeQuery = /** + * @param {?} selector + * @param {?} originalSelector + * @param {?} limit + * @param {?} includeSelf + * @param {?} optional + * @param {?} errors + * @return {?} + */ + function (selector, originalSelector, limit, includeSelf, optional, errors) { var /** @type {?} */ results = []; if (includeSelf) { results.push(this.element); } if (selector.length > 0) { + // if :self is only used then the selector is empty + selector = selector.replace(ENTER_TOKEN_REGEX, '.' + this._enterClassName); + selector = selector.replace(LEAVE_TOKEN_REGEX, '.' + this._leaveClassName); var /** @type {?} */ multi = limit != 1; var /** @type {?} */ elements = this._driver.query(this.element, selector, multi); if (limit !== 0) { - elements = elements.slice(0, limit); + elements = limit < 0 ? elements.slice(elements.length + limit, elements.length) : + elements.slice(0, limit); } results.push.apply(results, elements); } @@ -1744,13 +2242,9 @@ var AnimationTimelineContext = (function () { }; return AnimationTimelineContext; }()); -var TimelineBuilder = (function () { - /** - * @param {?} element - * @param {?} startTime - * @param {?=} _elementTimelineStylesLookup - */ - function TimelineBuilder(element, startTime, _elementTimelineStylesLookup) { +var TimelineBuilder = /** @class */ (function () { + function TimelineBuilder(_driver, element, startTime, _elementTimelineStylesLookup) { + this._driver = _driver; this.element = element; this.startTime = startTime; this._elementTimelineStylesLookup = _elementTimelineStylesLookup; @@ -1766,7 +2260,7 @@ var TimelineBuilder = (function () { this._elementTimelineStylesLookup = new Map(); } this._localTimelineStyles = Object.create(this._backFill, {}); - this._globalTimelineStyles = this._elementTimelineStylesLookup.get(element); + this._globalTimelineStyles = /** @type {?} */ ((this._elementTimelineStylesLookup.get(element))); if (!this._globalTimelineStyles) { this._globalTimelineStyles = this._localTimelineStyles; this._elementTimelineStylesLookup.set(element, this._localTimelineStyles); @@ -1776,7 +2270,10 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.containsAnimation = function () { + TimelineBuilder.prototype.containsAnimation = /** + * @return {?} + */ + function () { switch (this._keyframes.size) { case 0: return false; @@ -1789,12 +2286,15 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.getCurrentStyleProperties = function () { return Object.keys(this._currentKeyframe); }; + TimelineBuilder.prototype.getCurrentStyleProperties = /** + * @return {?} + */ + function () { return Object.keys(this._currentKeyframe); }; Object.defineProperty(TimelineBuilder.prototype, "currentTime", { - /** + get: /** * @return {?} */ - get: function () { return this.startTime + this.duration; }, + function () { return this.startTime + this.duration; }, enumerable: true, configurable: true }); @@ -1802,7 +2302,11 @@ var TimelineBuilder = (function () { * @param {?} delay * @return {?} */ - TimelineBuilder.prototype.delayNextStep = function (delay) { + TimelineBuilder.prototype.delayNextStep = /** + * @param {?} delay + * @return {?} + */ + function (delay) { // in the event that a style() step is placed right before a stagger() // and that style() step is the very first style() value in the animation // then we need to make a copy of the keyframe [0, copy, 1] so that the delay @@ -1823,18 +2327,26 @@ var TimelineBuilder = (function () { * @param {?=} currentTime * @return {?} */ - TimelineBuilder.prototype.fork = function (element, currentTime) { + TimelineBuilder.prototype.fork = /** + * @param {?} element + * @param {?=} currentTime + * @return {?} + */ + function (element, currentTime) { this.applyStylesToKeyframe(); - return new TimelineBuilder(element, currentTime || this.currentTime, this._elementTimelineStylesLookup); + return new TimelineBuilder(this._driver, element, currentTime || this.currentTime, this._elementTimelineStylesLookup); }; /** * @return {?} */ - TimelineBuilder.prototype._loadKeyframe = function () { + TimelineBuilder.prototype._loadKeyframe = /** + * @return {?} + */ + function () { if (this._currentKeyframe) { this._previousKeyframe = this._currentKeyframe; } - this._currentKeyframe = ((this._keyframes.get(this.duration))); + this._currentKeyframe = /** @type {?} */ ((this._keyframes.get(this.duration))); if (!this._currentKeyframe) { this._currentKeyframe = Object.create(this._backFill, {}); this._keyframes.set(this.duration, this._currentKeyframe); @@ -1843,7 +2355,10 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.forwardFrame = function () { + TimelineBuilder.prototype.forwardFrame = /** + * @return {?} + */ + function () { this.duration += ONE_FRAME_IN_MILLISECONDS; this._loadKeyframe(); }; @@ -1851,7 +2366,11 @@ var TimelineBuilder = (function () { * @param {?} time * @return {?} */ - TimelineBuilder.prototype.forwardTime = function (time) { + TimelineBuilder.prototype.forwardTime = /** + * @param {?} time + * @return {?} + */ + function (time) { this.applyStylesToKeyframe(); this.duration = time; this._loadKeyframe(); @@ -1861,7 +2380,12 @@ var TimelineBuilder = (function () { * @param {?} value * @return {?} */ - TimelineBuilder.prototype._updateStyle = function (prop, value) { + TimelineBuilder.prototype._updateStyle = /** + * @param {?} prop + * @param {?} value + * @return {?} + */ + function (prop, value) { this._localTimelineStyles[prop] = value; this._globalTimelineStyles[prop] = value; this._styleSummary[prop] = { time: this.currentTime, value: value }; @@ -1869,12 +2393,19 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.allowOnlyTimelineStyles = function () { return this._currentEmptyStepKeyframe !== this._currentKeyframe; }; + TimelineBuilder.prototype.allowOnlyTimelineStyles = /** + * @return {?} + */ + function () { return this._currentEmptyStepKeyframe !== this._currentKeyframe; }; /** * @param {?} easing * @return {?} */ - TimelineBuilder.prototype.applyEmptyStep = function (easing) { + TimelineBuilder.prototype.applyEmptyStep = /** + * @param {?} easing + * @return {?} + */ + function (easing) { var _this = this; if (easing) { this._previousKeyframe['easing'] = easing; @@ -1898,7 +2429,14 @@ var TimelineBuilder = (function () { * @param {?=} options * @return {?} */ - TimelineBuilder.prototype.setStyles = function (input, easing, errors, options) { + TimelineBuilder.prototype.setStyles = /** + * @param {?} input + * @param {?} easing + * @param {?} errors + * @param {?=} options + * @return {?} + */ + function (input, easing, errors, options) { var _this = this; if (easing) { this._previousKeyframe['easing'] = easing; @@ -1919,7 +2457,10 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.applyStylesToKeyframe = function () { + TimelineBuilder.prototype.applyStylesToKeyframe = /** + * @return {?} + */ + function () { var _this = this; var /** @type {?} */ styles = this._pendingStyles; var /** @type {?} */ props = Object.keys(styles); @@ -1939,7 +2480,10 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.snapshotCurrentStyles = function () { + TimelineBuilder.prototype.snapshotCurrentStyles = /** + * @return {?} + */ + function () { var _this = this; Object.keys(this._localTimelineStyles).forEach(function (prop) { var /** @type {?} */ val = _this._localTimelineStyles[prop]; @@ -1950,12 +2494,15 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.getFinalKeyframe = function () { return this._keyframes.get(this.duration); }; + TimelineBuilder.prototype.getFinalKeyframe = /** + * @return {?} + */ + function () { return this._keyframes.get(this.duration); }; Object.defineProperty(TimelineBuilder.prototype, "properties", { - /** + get: /** * @return {?} */ - get: function () { + function () { var /** @type {?} */ properties = []; for (var /** @type {?} */ prop in this._currentKeyframe) { properties.push(prop); @@ -1969,7 +2516,11 @@ var TimelineBuilder = (function () { * @param {?} timeline * @return {?} */ - TimelineBuilder.prototype.mergeTimelineCollectedStyles = function (timeline) { + TimelineBuilder.prototype.mergeTimelineCollectedStyles = /** + * @param {?} timeline + * @return {?} + */ + function (timeline) { var _this = this; Object.keys(timeline._styleSummary).forEach(function (prop) { var /** @type {?} */ details0 = _this._styleSummary[prop]; @@ -1982,7 +2533,10 @@ var TimelineBuilder = (function () { /** * @return {?} */ - TimelineBuilder.prototype.buildKeyframes = function () { + TimelineBuilder.prototype.buildKeyframes = /** + * @return {?} + */ + function () { var _this = this; this.applyStylesToKeyframe(); var /** @type {?} */ preStyleProps = new Set(); @@ -2019,19 +2573,11 @@ var TimelineBuilder = (function () { }; return TimelineBuilder; }()); -var SubTimelineBuilder = (function (_super) { +var SubTimelineBuilder = /** @class */ (function (_super) { __extends(SubTimelineBuilder, _super); - /** - * @param {?} element - * @param {?} keyframes - * @param {?} preStyleProps - * @param {?} postStyleProps - * @param {?} timings - * @param {?=} _stretchStartingKeyframe - */ - function SubTimelineBuilder(element, keyframes, preStyleProps, postStyleProps, timings, _stretchStartingKeyframe) { + function SubTimelineBuilder(driver, element, keyframes, preStyleProps, postStyleProps, timings, _stretchStartingKeyframe) { if (_stretchStartingKeyframe === void 0) { _stretchStartingKeyframe = false; } - var _this = _super.call(this, element, timings.delay) || this; + var _this = _super.call(this, driver, element, timings.delay) || this; _this.element = element; _this.keyframes = keyframes; _this.preStyleProps = preStyleProps; @@ -2043,11 +2589,17 @@ var SubTimelineBuilder = (function (_super) { /** * @return {?} */ - SubTimelineBuilder.prototype.containsAnimation = function () { return this.keyframes.length > 1; }; + SubTimelineBuilder.prototype.containsAnimation = /** + * @return {?} + */ + function () { return this.keyframes.length > 1; }; /** * @return {?} */ - SubTimelineBuilder.prototype.buildKeyframes = function () { + SubTimelineBuilder.prototype.buildKeyframes = /** + * @return {?} + */ + function () { var /** @type {?} */ keyframes = this.keyframes; var _a = this.timings, delay = _a.delay, duration = _a.duration, easing = _a.easing; if (this._stretchStartingKeyframe && delay) { @@ -2062,24 +2614,24 @@ var SubTimelineBuilder = (function (_super) { oldFirstKeyframe['offset'] = roundOffset(startingGap); newKeyframes.push(oldFirstKeyframe); /* - When the keyframe is stretched then it means that the delay before the animation - starts is gone. Instead the first keyframe is placed at the start of the animation - and it is then copied to where it starts when the original delay is over. This basically - means nothing animates during that delay, but the styles are still renderered. For this - to work the original offset values that exist in the original keyframes must be "warped" - so that they can take the new keyframe + delay into account. - - delay=1000, duration=1000, keyframes = 0 .5 1 - - turns into - - delay=0, duration=2000, keyframes = 0 .33 .66 1 - */ + When the keyframe is stretched then it means that the delay before the animation + starts is gone. Instead the first keyframe is placed at the start of the animation + and it is then copied to where it starts when the original delay is over. This basically + means nothing animates during that delay, but the styles are still renderered. For this + to work the original offset values that exist in the original keyframes must be "warped" + so that they can take the new keyframe + delay into account. + + delay=1000, duration=1000, keyframes = 0 .5 1 + + turns into + + delay=0, duration=2000, keyframes = 0 .33 .66 1 + */ // offsets between 1 ... n -1 are all warped by the keyframe stretch var /** @type {?} */ limit = keyframes.length - 1; for (var /** @type {?} */ i = 1; i <= limit; i++) { var /** @type {?} */ kf = copyStyles(keyframes[i], false); - var /** @type {?} */ oldOffset = (kf['offset']); + var /** @type {?} */ oldOffset = /** @type {?} */ (kf['offset']); var /** @type {?} */ timeAtKeyframe = delay + oldOffset * duration; kf['offset'] = roundOffset(timeAtKeyframe / totalTime); newKeyframes.push(kf); @@ -2123,24 +2675,18 @@ function flattenStyles(input, allStyles) { }); return styles; } + /** - * @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 + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc */ -var Animation = (function () { - /** - * @param {?} _driver - * @param {?} input - */ +var Animation = /** @class */ (function () { function Animation(_driver, input) { this._driver = _driver; - var errors = []; - var ast = buildAnimationAst(input, errors); + var /** @type {?} */ errors = []; + var /** @type {?} */ ast = buildAnimationAst(_driver, input, errors); if (errors.length) { - var errorMessage = "animation validation failed:\n" + errors.join("\n"); + var /** @type {?} */ errorMessage = "animation validation failed:\n" + errors.join("\n"); throw new Error(errorMessage); } this._animationAst = ast; @@ -2153,12 +2699,20 @@ var Animation = (function () { * @param {?=} subInstructions * @return {?} */ - Animation.prototype.buildTimelines = function (element, startingStyles, destinationStyles, options, subInstructions) { - var /** @type {?} */ start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) : (startingStyles); - var /** @type {?} */ dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) : (destinationStyles); + Animation.prototype.buildTimelines = /** + * @param {?} element + * @param {?} startingStyles + * @param {?} destinationStyles + * @param {?} options + * @param {?=} subInstructions + * @return {?} + */ + function (element, startingStyles, destinationStyles, options, subInstructions) { + var /** @type {?} */ start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) : /** @type {?} */ (startingStyles); + var /** @type {?} */ dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) : /** @type {?} */ (destinationStyles); var /** @type {?} */ errors = []; subInstructions = subInstructions || new ElementInstructionMap(); - var /** @type {?} */ result = buildAnimationTimelines(this._driver, element, this._animationAst, start, dest, options, subInstructions, errors); + var /** @type {?} */ result = buildAnimationTimelines(this._driver, element, this._animationAst, ENTER_CLASSNAME, LEAVE_CLASSNAME, start, dest, options, subInstructions, errors); if (errors.length) { var /** @type {?} */ errorMessage = "animation building failed:\n" + errors.join("\n"); throw new Error(errorMessage); @@ -2167,6 +2721,11 @@ var Animation = (function () { }; return Animation; }()); + +/** + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ /** * @license * Copyright Google Inc. All Rights Reserved. @@ -2175,39 +2734,56 @@ var Animation = (function () { * found in the LICENSE file at https://angular.io/license */ /** - * @experimental Animation support is experimental. + * \@experimental Animation support is experimental. + * @abstract */ -/** - * @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 - */ var AnimationStyleNormalizer = (function () { +var AnimationStyleNormalizer = /** @class */ (function () { function AnimationStyleNormalizer() { } return AnimationStyleNormalizer; }()); /** - * @experimental Animation support is experimental. + * \@experimental Animation support is experimental. */ -var NoopAnimationStyleNormalizer = (function () { +var NoopAnimationStyleNormalizer = /** @class */ (function () { function NoopAnimationStyleNormalizer() { } - NoopAnimationStyleNormalizer.prototype.normalizePropertyName = function (propertyName, errors) { return propertyName; }; - NoopAnimationStyleNormalizer.prototype.normalizeStyleValue = function (userProvidedProperty, normalizedProperty, value, errors) { - return value; + /** + * @param {?} propertyName + * @param {?} errors + * @return {?} + */ + NoopAnimationStyleNormalizer.prototype.normalizePropertyName = /** + * @param {?} propertyName + * @param {?} errors + * @return {?} + */ + function (propertyName, errors) { return propertyName; }; + /** + * @param {?} userProvidedProperty + * @param {?} normalizedProperty + * @param {?} value + * @param {?} errors + * @return {?} + */ + NoopAnimationStyleNormalizer.prototype.normalizeStyleValue
<TRUNCATED>
