http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/d07dd0f2/node_modules/@angular/animations/esm5/browser.js ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/esm5/browser.js b/node_modules/@angular/animations/esm5/browser.js new file mode 100644 index 0000000..e5efbef --- /dev/null +++ b/node_modules/@angular/animations/esm5/browser.js @@ -0,0 +1,6131 @@ +/** + * @license Angular v5.2.0 + * (c) 2010-2018 Google, Inc. https://angular.io/ + * License: MIT + */ +import { AUTO_STYLE, NoopAnimationPlayer, sequence, style, ɵAnimationGroupPlayer, ɵPRE_STYLE } from '@angular/animations'; +import { __assign, __extends } from 'tslib'; + +/** + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ +/** + * @param {?} players + * @return {?} + */ +function optimizeGroupPlayer(players) { + switch (players.length) { + case 0: + return new NoopAnimationPlayer(); + case 1: + return players[0]; + default: + return new ɵ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 /** @type {?} */ errors = []; + var /** @type {?} */ normalizedKeyframes = []; + var /** @type {?} */ previousOffset = -1; + var /** @type {?} */ previousKeyframe = null; + keyframes.forEach(function (kf) { + var /** @type {?} */ offset = /** @type {?} */ (kf['offset']); + var /** @type {?} */ isSameOffset = offset == previousOffset; + var /** @type {?} */ normalizedKeyframe = (isSameOffset && previousKeyframe) || {}; + Object.keys(kf).forEach(function (prop) { + var /** @type {?} */ normalizedProp = prop; + var /** @type {?} */ normalizedValue = kf[prop]; + if (prop !== 'offset') { + normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors); + switch (normalizedValue) { + case ɵPRE_STYLE: + normalizedValue = preStyles[prop]; + break; + case AUTO_STYLE: + normalizedValue = postStyles[prop]; + break; + default: + normalizedValue = + normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors); + break; + } + } + normalizedKeyframe[normalizedProp] = normalizedValue; + }); + if (!isSameOffset) { + normalizedKeyframes.push(normalizedKeyframe); + } + previousKeyframe = normalizedKeyframe; + previousOffset = offset; + }); + if (errors.length) { + 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': + player.onStart(function () { return callback(event && copyAnimationEvent(event, 'start', player.totalTime)); }); + break; + case 'done': + player.onDone(function () { return callback(event && copyAnimationEvent(event, 'done', player.totalTime)); }); + break; + case 'destroy': + player.onDestroy(function () { return callback(event && copyAnimationEvent(event, 'destroy', player.totalTime)); }); + break; + } +} +/** + * @param {?} e + * @param {?=} phaseName + * @param {?=} totalTime + * @return {?} + */ +function copyAnimationEvent(e, phaseName, totalTime) { + 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) { + (/** @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 /** @type {?} */ value; + if (map instanceof Map) { + value = map.get(key); + if (!value) { + map.set(key, value = defaultValue); + } + } + else { + value = map[key]; + if (!value) { + value = map[key] = defaultValue; + } + } + return value; +} +/** + * @param {?} command + * @return {?} + */ +function parseTimelineCommand(command) { + 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 _query = function (element, selector, multi) { + return []; +}; +if (typeof Element != 'undefined') { + // this is well supported in all browsers + _contains = function (elm1, elm2) { return /** @type {?} */ (elm1.contains(elm2)); }; + if (Element.prototype.matches) { + _matches = function (element, selector) { return element.matches(selector); }; + } + else { + 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 /** @type {?} */ results = []; + if (multi) { + results.push.apply(results, element.querySelectorAll(selector)); + } + else { + var /** @type {?} */ elm = element.querySelector(selector); + if (elm) { + results.push(elm); + } + } + 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; + +/** + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ +/** + * \@experimental + */ +var NoopAnimationDriver = /** @class */ (function () { + function NoopAnimationDriver() { + } + /** + * @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); + }; + /** + * @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); + }; + /** + * @param {?} element + * @param {?} prop + * @param {?=} defaultValue + * @return {?} + */ + NoopAnimationDriver.prototype.computeStyle = /** + * @param {?} element + * @param {?} prop + * @param {?=} defaultValue + * @return {?} + */ + function (element, prop, defaultValue) { + return defaultValue || ''; + }; + /** + * @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 NoopAnimationPlayer(); + }; + return NoopAnimationDriver; +}()); +/** + * \@experimental + * @abstract + */ +var AnimationDriver = /** @class */ (function () { + function AnimationDriver() { + } + AnimationDriver.NOOP = new NoopAnimationDriver(); + return AnimationDriver; +}()); + +/** + * @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 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 /** @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') ? /** @type {?} */ (timings) : + parseTimeExpression(/** @type {?} */ (timings), errors, allowNegativeValues); +} +/** + * @param {?} exp + * @param {?} errors + * @param {?=} allowNegativeValues + * @return {?} + */ +function parseTimeExpression(exp, errors, allowNegativeValues) { + 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 /** @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 /** @type {?} */ delayMatch = matches[3]; + if (delayMatch != null) { + delay = _convertTimeValueToMS(Math.floor(parseFloat(delayMatch)), matches[4]); + } + var /** @type {?} */ easingVal = matches[5]; + if (easingVal) { + easing = easingVal; + } + } + else { + duration = /** @type {?} */ (exp); + } + if (!allowNegativeValues) { + 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; + } + if (delay < 0) { + errors.push("Delay values below 0 are not allowed for this animation step."); + containsErrors = true; + } + if (containsErrors) { + errors.splice(startIndex, 0, "The provided timing value \"" + exp + "\" is invalid."); + } + } + 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 /** @type {?} */ normalizedStyles = {}; + if (Array.isArray(styles)) { + styles.forEach(function (data) { return copyStyles(data, false, normalizedStyles); }); + } + else { + copyStyles(styles, false, normalizedStyles); + } + 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 /** @type {?} */ prop in styles) { + destination[prop] = styles[prop]; + } + } + else { + copyObj(styles, destination); + } + return destination; +} +/** + * @param {?} element + * @param {?} styles + * @return {?} + */ +function setStyles(element, styles) { + if (element['style']) { + Object.keys(styles).forEach(function (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 /** @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 sequence(steps); + } + return /** @type {?} */ (steps); +} +/** + * @param {?} value + * @param {?} options + * @param {?} errors + * @return {?} + */ +function validateStyleParams(value, options, errors) { + var /** @type {?} */ params = options.params || {}; + var /** @type {?} */ matches = extractStyleParams(value); + if (matches.length) { + matches.forEach(function (varName) { + if (!params.hasOwnProperty(varName)) { + errors.push("Unable to resolve the local animation param " + varName + " in the given list of values"); + } + }); + } +} +var PARAM_REGEX = new RegExp(SUBSTITUTION_EXPR_START + "\\s*(.+?)\\s*" + SUBSTITUTION_EXPR_END, 'g'); +/** + * @param {?} value + * @return {?} + */ +function extractStyleParams(value) { + var /** @type {?} */ params = []; + if (typeof value === 'string') { + var /** @type {?} */ val = value.toString(); + var /** @type {?} */ match = void 0; + while (match = PARAM_REGEX.exec(val)) { + params.push(/** @type {?} */ (match[1])); + } + PARAM_REGEX.lastIndex = 0; + } + return params; +} +/** + * @param {?} value + * @param {?} params + * @param {?} errors + * @return {?} + */ +function interpolateParams(value, params, errors) { + 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); + localVal = ''; + } + return localVal.toString(); + }); + // we do this to assert that numeric values stay as they are + return str == original ? value : str; +} +/** + * @param {?} iterator + * @return {?} + */ +function iteratorToArray(iterator) { + 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 = []; + for (var _i = 0; _i < arguments.length; _i++) { + m[_i] = arguments[_i]; + } + 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 */: + return visitor.visitTrigger(node, context); + case 0 /* State */: + return visitor.visitState(node, context); + case 1 /* Transition */: + return visitor.visitTransition(node, context); + case 2 /* Sequence */: + return visitor.visitSequence(node, context); + case 3 /* Group */: + return visitor.visitGroup(node, context); + case 4 /* Animate */: + return visitor.visitAnimate(node, context); + case 5 /* Keyframes */: + return visitor.visitKeyframes(node, context); + case 6 /* Style */: + return visitor.visitStyle(node, context); + case 8 /* Reference */: + return visitor.visitReference(node, context); + case 9 /* AnimateChild */: + return visitor.visitAnimateChild(node, context); + case 10 /* AnimateRef */: + return visitor.visitAnimateRef(node, context); + case 11 /* Query */: + return visitor.visitQuery(node, context); + case 12 /* Stagger */: + return visitor.visitStagger(node, context); + default: + 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. + * + * 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 ANY_STATE = '*'; +/** + * @param {?} transitionValue + * @param {?} errors + * @return {?} + */ +function parseTransitionExpr(transitionValue, errors) { + var /** @type {?} */ expressions = []; + if (typeof transitionValue == 'string') { + (/** @type {?} */ (transitionValue)) + .split(/\s*,\s*/) + .forEach(function (str) { return parseInnerTransitionStr(str, expressions, errors); }); + } + else { + expressions.push(/** @type {?} */ (transitionValue)); + } + return expressions; +} +/** + * @param {?} eventStr + * @param {?} expressions + * @param {?} errors + * @return {?} + */ +function parseInnerTransitionStr(eventStr, expressions, errors) { + if (eventStr[0] == ':') { + 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) { + errors.push("The provided transition expression \"" + eventStr + "\" is not supported"); + return expressions; + } + var /** @type {?} */ fromState = match[1]; + var /** @type {?} */ separator = match[2]; + var /** @type {?} */ toState = match[3]; + expressions.push(makeLambdaFromStates(fromState, toState)); + var /** @type {?} */ isFullAnyStateExpr = fromState == ANY_STATE && toState == ANY_STATE; + if (separator[0] == '<' && !isFullAnyStateExpr) { + expressions.push(makeLambdaFromStates(toState, fromState)); + } +} +/** + * @param {?} alias + * @param {?} errors + * @return {?} + */ +function parseAnimationAlias(alias, errors) { + switch (alias) { + case ':enter': + 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 '* => *'; + } +} +// 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 + * @return {?} + */ +function makeLambdaFromStates(lhs, rhs) { + var /** @type {?} */ LHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(lhs) || FALSE_BOOLEAN_VALUES.has(lhs); + var /** @type {?} */ RHS_MATCH_BOOLEAN = TRUE_BOOLEAN_VALUES.has(rhs) || FALSE_BOOLEAN_VALUES.has(rhs); + return function (fromState, toState) { + var /** @type {?} */ lhsMatch = lhs == ANY_STATE || lhs == fromState; + var /** @type {?} */ rhsMatch = rhs == ANY_STATE || rhs == toState; + if (!lhsMatch && LHS_MATCH_BOOLEAN && typeof fromState === 'boolean') { + lhsMatch = fromState ? TRUE_BOOLEAN_VALUES.has(lhs) : FALSE_BOOLEAN_VALUES.has(lhs); + } + if (!rhsMatch && RHS_MATCH_BOOLEAN && typeof toState === 'boolean') { + rhsMatch = toState ? TRUE_BOOLEAN_VALUES.has(rhs) : FALSE_BOOLEAN_VALUES.has(rhs); + } + return lhsMatch && rhsMatch; + }; +} + +/** + * @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(driver, metadata, errors) { + return new AnimationAstBuilderVisitor(driver).build(metadata, errors); +} +var ROOT_SELECTOR = ''; +var AnimationAstBuilderVisitor = /** @class */ (function () { + function AnimationAstBuilderVisitor(_driver) { + this._driver = _driver; + } + /** + * @param {?} metadata + * @param {?} errors + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.build = /** + * @param {?} metadata + * @param {?} errors + * @return {?} + */ + function (metadata, errors) { + var /** @type {?} */ context = new AnimationAstBuilderContext(errors); + this._resetContextStyleTimingState(context); + return /** @type {?} */ (visitDslNode(this, normalizeAnimationEntry(metadata), context)); + }; + /** + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype._resetContextStyleTimingState = /** + * @param {?} context + * @return {?} + */ + function (context) { + context.currentQuerySelector = ROOT_SELECTOR; + context.collectedStyles = {}; + context.collectedStyles[ROOT_SELECTOR] = {}; + context.currentTime = 0; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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 = /** @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_1; + } + else if (def.type == 1 /* Transition */) { + var /** @type {?} */ transition = _this.visitTransition(/** @type {?} */ (def), context); + queryCount += transition.queryCount; + depCount += transition.depCount; + transitions.push(transition); + } + else { + context.errors.push('only state() and transition() definitions can sit inside of a trigger()'); + } + }); + return { + type: 7 /* Trigger */, + name: metadata.name, states: states, transitions: transitions, queryCount: queryCount, depCount: depCount, + options: null + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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) { + var /** @type {?} */ missingSubs_1 = new Set(); + var /** @type {?} */ params_1 = astParams || {}; + styleAst.styles.forEach(function (value) { + if (isObject(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)) { + missingSubs_1.add(sub); + } + }); + }); + } + }); + if (missingSubs_1.size) { + var /** @type {?} */ missingSubsArr = iteratorToArray(missingSubs_1.values()); + context.errors.push("state(\"" + metadata.name + "\", ...) must define default values for all the following style substitutions: " + missingSubsArr.join(', ')); + } + } + return { + type: 0 /* State */, + name: metadata.name, + style: styleAst, + options: astParams ? { params: astParams } : null + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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); + var /** @type {?} */ matchers = parseTransitionExpr(metadata.expr, context.errors); + return { + type: 1 /* Transition */, + matchers: matchers, + animation: animation, + queryCount: context.queryCount, + depCount: context.depCount, + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.visitSequence = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + var _this = this; + return { + type: 2 /* Sequence */, + steps: metadata.steps.map(function (s) { return visitDslNode(_this, s, context); }), + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.visitGroup = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + var _this = this; + var /** @type {?} */ currentTime = context.currentTime; + var /** @type {?} */ furthestTime = 0; + var /** @type {?} */ steps = metadata.steps.map(function (step) { + context.currentTime = currentTime; + var /** @type {?} */ innerAst = visitDslNode(_this, step, context); + furthestTime = Math.max(furthestTime, context.currentTime); + return innerAst; + }); + context.currentTime = furthestTime; + return { + type: 3 /* Group */, + steps: steps, + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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; + var /** @type {?} */ styleMetadata = metadata.styles ? metadata.styles : style({}); + if (styleMetadata.type == 5 /* Keyframes */) { + styleAst = this.visitKeyframes(/** @type {?} */ (styleMetadata), context); + } + else { + var /** @type {?} */ styleMetadata_1 = /** @type {?} */ (metadata.styles); + var /** @type {?} */ isEmpty = false; + if (!styleMetadata_1) { + isEmpty = true; + var /** @type {?} */ newStyleData = {}; + if (timingAst.easing) { + newStyleData['easing'] = timingAst.easing; + } + styleMetadata_1 = style(newStyleData); + } + context.currentTime += timingAst.duration + timingAst.delay; + var /** @type {?} */ _styleAst = this.visitStyle(styleMetadata_1, context); + _styleAst.isEmptyStep = isEmpty; + styleAst = _styleAst; + } + context.currentAnimateTimings = null; + return { + type: 4 /* Animate */, + timings: timingAst, + style: styleAst, + options: null + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.visitStyle = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + var /** @type {?} */ ast = this._makeStyleAst(metadata, context); + this._validateStyleAst(ast, context); + return ast; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype._makeStyleAst = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + var /** @type {?} */ styles = []; + if (Array.isArray(metadata.styles)) { + (/** @type {?} */ (metadata.styles)).forEach(function (styleTuple) { + if (typeof styleTuple == 'string') { + if (styleTuple == AUTO_STYLE) { + styles.push(/** @type {?} */ (styleTuple)); + } + else { + context.errors.push("The provided style string value " + styleTuple + " is not allowed."); + } + } + else { + styles.push(/** @type {?} */ (styleTuple)); + } + }); + } + else { + styles.push(metadata.styles); + } + var /** @type {?} */ containsDynamicStyles = false; + var /** @type {?} */ collectedEasing = null; + styles.forEach(function (styleData) { + if (isObject(styleData)) { + var /** @type {?} */ styleMap = /** @type {?} */ (styleData); + var /** @type {?} */ easing = styleMap['easing']; + if (easing) { + collectedEasing = /** @type {?} */ (easing); + delete styleMap['easing']; + } + if (!containsDynamicStyles) { + for (var /** @type {?} */ prop in styleMap) { + var /** @type {?} */ value = styleMap[prop]; + if (value.toString().indexOf(SUBSTITUTION_EXPR_START) >= 0) { + containsDynamicStyles = true; + break; + } + } + } + } + }); + return { + type: 6 /* Style */, + styles: styles, + easing: collectedEasing, + offset: metadata.offset, containsDynamicStyles: containsDynamicStyles, + options: null + }; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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; + if (timings && startTime > 0) { + startTime -= timings.duration + timings.delay; + } + ast.styles.forEach(function (tuple) { + if (typeof tuple == 'string') + return; + Object.keys(tuple).forEach(function (prop) { + 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) { + if (startTime != endTime && startTime >= collectedEntry.startTime && + endTime <= collectedEntry.endTime) { + context.errors.push("The CSS property \"" + prop + "\" that exists between the times of \"" + collectedEntry.startTime + "ms\" and \"" + collectedEntry.endTime + "ms\" is also being animated in a parallel animation between the times of \"" + startTime + "ms\" and \"" + endTime + "ms\""); + updateCollectedStyle = false; + } + // we always choose the smaller start time value since we + // want to have a record of the entire animation window where + // the style property is being animated in between + startTime = collectedEntry.startTime; + } + if (updateCollectedStyle) { + collectedStyles[prop] = { startTime: startTime, endTime: endTime }; + } + if (context.options) { + validateStyleParams(tuple[prop], context.options, context.errors); + } + }); + }); + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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) { + context.errors.push("keyframes() must be placed inside of a call to animate()"); + return ast; + } + var /** @type {?} */ MAX_KEYFRAME_OFFSET = 1; + var /** @type {?} */ totalKeyframesWithOffsets = 0; + var /** @type {?} */ offsets = []; + var /** @type {?} */ offsetsOutOfOrder = false; + var /** @type {?} */ keyframesOutOfRange = false; + var /** @type {?} */ previousOffset = 0; + var /** @type {?} */ keyframes = metadata.steps.map(function (styles) { + var /** @type {?} */ style$$1 = _this._makeStyleAst(styles, context); + var /** @type {?} */ offsetVal = style$$1.offset != null ? style$$1.offset : consumeOffset(style$$1.styles); + var /** @type {?} */ offset = 0; + if (offsetVal != null) { + totalKeyframesWithOffsets++; + offset = style$$1.offset = offsetVal; + } + keyframesOutOfRange = keyframesOutOfRange || offset < 0 || offset > 1; + offsetsOutOfOrder = offsetsOutOfOrder || offset < previousOffset; + previousOffset = offset; + offsets.push(offset); + return style$$1; + }); + if (keyframesOutOfRange) { + context.errors.push("Please ensure that all keyframe offsets are between 0 and 1"); + } + if (offsetsOutOfOrder) { + context.errors.push("Please ensure that all keyframe offsets are in order"); + } + var /** @type {?} */ length = metadata.steps.length; + var /** @type {?} */ generatedOffset = 0; + if (totalKeyframesWithOffsets > 0 && totalKeyframesWithOffsets < length) { + context.errors.push("Not all style() steps within the declared keyframes() contain offsets"); + } + else if (totalKeyframesWithOffsets == 0) { + generatedOffset = MAX_KEYFRAME_OFFSET / (length - 1); + } + var /** @type {?} */ limit = length - 1; + var /** @type {?} */ currentTime = context.currentTime; + 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]; + var /** @type {?} */ durationUpToThisFrame = offset * animateDuration; + context.currentTime = currentTime + currentAnimateTimings.delay + durationUpToThisFrame; + currentAnimateTimings.duration = durationUpToThisFrame; + _this._validateStyleAst(kf, context); + kf.offset = offset; + ast.styles.push(kf); + }); + return ast; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.visitReference = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + return { + type: 8 /* Reference */, + animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context), + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.visitAnimateChild = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + context.depCount++; + return { + type: 9 /* AnimateChild */, + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + AnimationAstBuilderVisitor.prototype.visitAnimateRef = /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + function (metadata, context) { + return { + type: 10 /* AnimateRef */, + animation: this.visitReference(metadata.animation, context), + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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]; + context.currentQuerySelector = + parentSelector.length ? (parentSelector + ' ' + selector) : selector; + getOrSetAsInMap(context.collectedStyles, context.currentQuerySelector, {}); + var /** @type {?} */ animation = visitDslNode(this, normalizeAnimationEntry(metadata.animation), context); + context.currentQuery = null; + context.currentQuerySelector = parentSelector; + return { + type: 11 /* Query */, + selector: selector, + limit: options.limit || 0, + optional: !!options.optional, includeSelf: includeSelf, animation: animation, + originalSelector: metadata.selector, + options: normalizeAnimationOptions(metadata.options) + }; + }; + /** + * @param {?} metadata + * @param {?} context + * @return {?} + */ + 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()"); + } + var /** @type {?} */ timings = metadata.timings === 'full' ? + { duration: 0, delay: 0, easing: 'full' } : + resolveTiming(metadata.timings, context.errors, true); + return { + type: 12 /* Stagger */, + animation: visitDslNode(this, normalizeAnimationEntry(metadata.animation), context), timings: timings, + options: null + }; + }; + return AnimationAstBuilderVisitor; +}()); +/** + * @param {?} selector + * @return {?} + */ +function normalizeSelector(selector) { + var /** @type {?} */ hasAmpersand = selector.split(/\s*,\s*/).find(function (token) { return token == SELF_TOKEN; }) ? true : false; + if (hasAmpersand) { + selector = selector.replace(SELF_TOKEN_REGEX, ''); + } + // 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]; +} +/** + * @param {?} obj + * @return {?} + */ +function normalizeParams(obj) { + return obj ? copyObj(obj) : null; +} +var AnimationAstBuilderContext = /** @class */ (function () { + function AnimationAstBuilderContext(errors) { + this.errors = errors; + this.queryCount = 0; + this.depCount = 0; + this.currentTransition = null; + this.currentQuery = null; + this.currentQuerySelector = null; + this.currentAnimateTimings = null; + this.currentTime = 0; + this.collectedStyles = {}; + this.options = null; + } + return AnimationAstBuilderContext; +}()); +/** + * @param {?} styles + * @return {?} + */ +function consumeOffset(styles) { + if (typeof styles == 'string') + return null; + var /** @type {?} */ offset = null; + if (Array.isArray(styles)) { + styles.forEach(function (styleTuple) { + if (isObject(styleTuple) && styleTuple.hasOwnProperty('offset')) { + var /** @type {?} */ obj = /** @type {?} */ (styleTuple); + offset = parseFloat(/** @type {?} */ (obj['offset'])); + delete obj['offset']; + } + }); + } + else if (isObject(styles) && styles.hasOwnProperty('offset')) { + var /** @type {?} */ obj = /** @type {?} */ (styles); + offset = parseFloat(/** @type {?} */ (obj['offset'])); + delete obj['offset']; + } + return offset; +} +/** + * @param {?} value + * @return {?} + */ +function isObject(value) { + return !Array.isArray(value) && typeof value == 'object'; +} +/** + * @param {?} value + * @param {?} errors + * @return {?} + */ +function constructTimingAst(value, errors) { + var /** @type {?} */ timings = null; + if (value.hasOwnProperty('duration')) { + timings = /** @type {?} */ (value); + } + else if (typeof value == 'number') { + var /** @type {?} */ duration = resolveTiming(/** @type {?} */ (value), errors).duration; + return makeTimingAst(/** @type {?} */ (duration), 0, ''); + } + 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 = /** @type {?} */ (makeTimingAst(0, 0, '')); + ast.dynamic = true; + ast.strValue = strValue; + return /** @type {?} */ (ast); + } + timings = timings || resolveTiming(strValue, errors); + return makeTimingAst(timings.duration, timings.delay, timings.easing); +} +/** + * @param {?} options + * @return {?} + */ +function normalizeAnimationOptions(options) { + if (options) { + options = copyObj(options); + if (options['params']) { + options['params'] = /** @type {?} */ ((normalizeParams(options['params']))); + } + } + else { + options = {}; + } + return options; +} +/** + * @param {?} duration + * @param {?} delay + * @param {?} easing + * @return {?} + */ +function makeTimingAst(duration, delay, easing) { + return { duration: duration, delay: delay, easing: easing }; +} + +/** + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ +/** + * @record + */ + +/** + * @param {?} element + * @param {?} keyframes + * @param {?} preStyleProps + * @param {?} postStyleProps + * @param {?} duration + * @param {?} delay + * @param {?=} easing + * @param {?=} subTimeline + * @return {?} + */ +function createTimelineInstruction(element, keyframes, preStyleProps, postStyleProps, duration, delay, easing, subTimeline) { + if (easing === void 0) { easing = null; } + if (subTimeline === void 0) { subTimeline = false; } + return { + type: 1 /* TimelineAnimation */, + element: element, + keyframes: keyframes, + preStyleProps: preStyleProps, + postStyleProps: postStyleProps, + duration: duration, + delay: delay, + totalTime: duration + delay, easing: easing, subTimeline: subTimeline + }; +} + +/** + * @fileoverview added by tsickle + * @suppress {checkTypes} checked by tsc + */ +var ElementInstructionMap = /** @class */ (function () { + function ElementInstructionMap() { + this._map = new Map(); + } + /** + * @param {?} element + * @return {?} + */ + ElementInstructionMap.prototype.consume = /** + * @param {?} element + * @return {?} + */ + function (element) { + var /** @type {?} */ instructions = this._map.get(element); + if (instructions) { + this._map.delete(element); + } + else { + instructions = []; + } + return instructions; + }; + /** + * @param {?} element + * @param {?} instructions + * @return {?} + */ + 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 = []); + } + existingInstructions.push.apply(existingInstructions, instructions); + }; + /** + * @param {?} element + * @return {?} + */ + ElementInstructionMap.prototype.has = /** + * @param {?} element + * @return {?} + */ + function (element) { return this._map.has(element); }; + /** + * @return {?} + */ + ElementInstructionMap.prototype.clear = /** + * @return {?} + */ + function () { this._map.clear(); }; + return ElementInstructionMap; +}()); + +/** + * @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 + * @param {?=} subInstructions + * @param {?=} errors + * @return {?} + */ +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, enterClassName, leaveClassName, startingStyles, finalStyles, options, subInstructions, errors); +} +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 + * @param {?=} subInstructions + * @param {?=} errors + * @return {?} + */ + 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, enterClassName, leaveClassName, errors, []); + context.options = options; + context.currentTimeline.setStyles([startingStyles], null, context.errors, options); + visitDslNode(this, ast, context); + // this checks to see if an actual animation happened + var /** @type {?} */ timelines = context.timelines.filter(function (timeline) { return timeline.containsAnimation(); }); + if (timelines.length && Object.keys(finalStyles).length) { + var /** @type {?} */ tl = timelines[timelines.length - 1]; + if (!tl.allowOnlyTimelineStyles()) { + tl.setStyles([finalStyles], null, context.errors, options); + } + } + return timelines.length ? timelines.map(function (timeline) { return timeline.buildKeyframes(); }) : + [createTimelineInstruction(rootElement, [], [], [], 0, 0, '', false)]; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitTrigger = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + // these values are not visited in this AST + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitState = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + // these values are not visited in this AST + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitTransition = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + // these values are not visited in this AST + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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); + var /** @type {?} */ startTime = context.currentTimeline.currentTime; + var /** @type {?} */ endTime = this._visitSubInstructions(elementInstructions, innerContext, /** @type {?} */ (innerContext.options)); + if (startTime != endTime) { + // we do this on the upper context because we created a sub context for + // the sub child animations + context.transformIntoNewTimeline(endTime); + } + } + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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); + context.transformIntoNewTimeline(innerContext.currentTimeline.currentTime); + context.previousNode = ast; + }; + /** + * @param {?} instructions + * @param {?} context + * @param {?} options + * @return {?} + */ + 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 + // animation from being fired entirely. + var /** @type {?} */ duration = options.duration != null ? resolveTimingValue(options.duration) : null; + var /** @type {?} */ delay = options.delay != null ? resolveTimingValue(options.delay) : null; + if (duration !== 0) { + instructions.forEach(function (instruction) { + var /** @type {?} */ instructionTimings = context.appendInstructionToTimeline(instruction, duration, delay); + furthestTime = + Math.max(furthestTime, instructionTimings.duration + instructionTimings.delay); + }); + } + return furthestTime; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitReference = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + context.updateOptions(ast.options, true); + visitDslNode(this, ast.animation, context); + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitSequence = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + var _this = this; + var /** @type {?} */ subContextCount = context.subContextCount; + var /** @type {?} */ ctx = context; + var /** @type {?} */ options = ast.options; + if (options && (options.params || options.delay)) { + ctx = context.createSubContext(options); + ctx.transformIntoNewTimeline(); + if (options.delay != null) { + if (ctx.previousNode.type == 6 /* Style */) { + ctx.currentTimeline.snapshotCurrentStyles(); + ctx.previousNode = DEFAULT_NOOP_PREVIOUS_NODE; + } + var /** @type {?} */ delay = resolveTimingValue(options.delay); + ctx.delayNextStep(delay); + } + } + if (ast.steps.length) { + ast.steps.forEach(function (s) { return visitDslNode(_this, s, ctx); }); + // this is here just incase the inner steps only contain or end with a style() call + ctx.currentTimeline.applyStylesToKeyframe(); + // this means that some animation function within the sequence + // ended up creating a sub timeline (which means the current + // timeline cannot overlap with the contents of the sequence) + if (ctx.subContextCount > subContextCount) { + ctx.transformIntoNewTimeline(); + } + } + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitGroup = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + var _this = this; + var /** @type {?} */ innerTimelines = []; + var /** @type {?} */ furthestTime = context.currentTimeline.currentTime; + var /** @type {?} */ delay = ast.options && ast.options.delay ? resolveTimingValue(ast.options.delay) : 0; + ast.steps.forEach(function (s) { + var /** @type {?} */ innerContext = context.createSubContext(ast.options); + if (delay) { + innerContext.delayNextStep(delay); + } + visitDslNode(_this, s, innerContext); + furthestTime = Math.max(furthestTime, innerContext.currentTimeline.currentTime); + innerTimelines.push(innerContext.currentTimeline); + }); + // this operation is run after the AST loop because otherwise + // if the parent timeline's collected styles were updated then + // it would pass in invalid data into the new-to-be forked items + innerTimelines.forEach(function (timeline) { return context.currentTimeline.mergeTimelineCollectedStyles(timeline); }); + context.transformIntoNewTimeline(furthestTime); + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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); + } + else { + return { duration: ast.duration, delay: ast.delay, easing: ast.easing }; + } + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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) { + context.incrementTime(timings.delay); + timeline.snapshotCurrentStyles(); + } + var /** @type {?} */ style$$1 = ast.style; + if (style$$1.type == 5 /* Keyframes */) { + this.visitKeyframes(style$$1, context); + } + else { + context.incrementTime(timings.duration); + this.visitStyle(/** @type {?} */ (style$$1), context); + timeline.applyStylesToKeyframe(); + } + context.currentAnimateTimings = null; + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + AnimationTimelineBuilderVisitor.prototype.visitStyle = /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + function (ast, context) { + var /** @type {?} */ timeline = context.currentTimeline; + 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) { + timeline.forwardFrame(); + } + var /** @type {?} */ easing = (timings && timings.easing) || ast.easing; + if (ast.isEmptyStep) { + timeline.applyEmptyStep(easing); + } + else { + timeline.setStyles(ast.styles, easing, context.errors, context.options); + } + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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; + innerTimeline.easing = currentAnimateTimings.easing; + ast.styles.forEach(function (step) { + var /** @type {?} */ offset = step.offset || 0; + innerTimeline.forwardTime(offset * duration); + innerTimeline.setStyles(step.styles, step.easing, context.errors, context.options); + innerTimeline.applyStylesToKeyframe(); + }); + // this will ensure that the parent timeline gets all the styles from + // the child even if the new timeline below is not used + context.currentTimeline.mergeTimelineCollectedStyles(innerTimeline); + // we do this because the window between this timeline and the sub timeline + // should ensure that the styles within are exactly the same as they were before + context.transformIntoNewTimeline(startTime + duration); + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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 = /** @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))) { + context.currentTimeline.snapshotCurrentStyles(); + context.previousNode = DEFAULT_NOOP_PREVIOUS_NODE; + } + var /** @type {?} */ furthestTime = startTime; + var /** @type {?} */ elms = context.invokeQuery(ast.selector, ast.originalSelector, ast.limit, ast.includeSelf, options.optional ? true : false, context.errors); + context.currentQueryTotal = elms.length; + var /** @type {?} */ sameElementTimeline = null; + elms.forEach(function (element, i) { + context.currentQueryIndex = i; + var /** @type {?} */ innerContext = context.createSubContext(ast.options, element); + if (delay) { + innerContext.delayNextStep(delay); + } + if (element === context.element) { + sameElementTimeline = innerContext.currentTimeline; + } + visitDslNode(_this, ast.animation, innerContext); + // this is here just incase the inner steps only contain or end + // with a style() call (which is here to signal that this is a preparatory + // call to style an element before it is animated again) + innerContext.currentTimeline.applyStylesToKeyframe(); + var /** @type {?} */ endTime = innerContext.currentTimeline.currentTime; + furthestTime = Math.max(furthestTime, endTime); + }); + context.currentQueryIndex = 0; + context.currentQueryTotal = 0; + context.transformIntoNewTimeline(furthestTime); + if (sameElementTimeline) { + context.currentTimeline.mergeTimelineCollectedStyles(sameElementTimeline); + context.currentTimeline.snapshotCurrentStyles(); + } + context.previousNode = ast; + }; + /** + * @param {?} ast + * @param {?} context + * @return {?} + */ + 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); + var /** @type {?} */ maxTime = duration * (context.currentQueryTotal - 1); + var /** @type {?} */ delay = duration * context.currentQueryIndex; + var /** @type {?} */ staggerTransformer = timings.duration < 0 ? 'reverse' : timings.easing; + switch (staggerTransformer) { + case 'reverse': + delay = maxTime - delay; + break; + case 'full': + delay = parentContext.currentStaggerTime; + break; + } + var /** @type {?} */ timeline = context.currentTimeline; + if (delay) { + timeline.delayNextStep(delay); + } + var /** @type {?} */ startingTime = timeline.currentTime; + visitDslNode(this, ast.animation, context); + context.previousNode = ast; + // time = duration + delay + // the reason why this computation is so complex is because + // the inner timeline may either have a delay value or a stretched + // keyframe depending on if a subtimeline is not used or is used. + parentContext.currentStaggerTime = + (tl.currentTime - startingTime) + (tl.startTime - parentContext.currentTimeline.startTime); + }; + return AnimationTimelineBuilderVisitor; +}()); +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; + this.currentAnimateTimings = null; + this.previousNode = DEFAULT_NOOP_PREVIOUS_NODE; + this.subContextCount = 0; + this.options = {}; + this.currentQueryIndex = 0; + this.currentQueryTotal = 0; + this.currentStaggerTime = 0; + this.currentTimeline = initialTimeline || new TimelineBuilder(this._driver, element, 0); + timelines.push(this.currentTimeline); + } + Object.defineProperty(AnimationTimelineContext.prototype, "params", { + get: /** + * @return {?} + */ + function () { return this.options.params; }, + enumerable: true, + configurable: true + }); + /** + * @param {?} options + * @param {?=} skipIfExists + * @return {?} + */ + AnimationTimelineContext.prototype.updateOptions = /** + * @param {?} options + * @param {?=} skipIfExists + * @return {?} + */ + function (options, skipIfExists) { + var _this = this; + if (!options) + return; + 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) { + (/** @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 = /** @type {?} */ ((optionsToUpdate.params)); + if (!paramsToUpdate_1) { + paramsToUpdate_1 = this.options.params = {}; + } + Object.keys(newParams).forEach(function (name) { + if (!skipIfExists || !paramsToUpdate_1.hasOwnProperty(name)) { + paramsToUpdate_1[name] = interpolateParams(newParams[name], paramsToUpdate_1, _this.errors); + } + }); + } + }; + /** + * @return {?} + */ + AnimationTimelineContext.prototype._copyOptions = /** + * @return {?} + */ + function () { + var /** @type {?} */ options = {}; + if (this.options) { + var /** @type {?} */ oldParams_1 = this.options.params; + if (oldParams_1) { + var /** @type {?} */ params_1 = options['params'] = {}; + Object.keys(oldParams_1).forEach(function (name) { params_1[name] = oldParams_1[name]; }); + } + } + return options; + }; + /** + * @param {?=} options + * @param {?=} element + * @param {?=} newTime + * @return {?} + */ + 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._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(); + context.updateOptions(options); + context.currentQueryIndex = this.currentQueryIndex; + context.currentQueryTotal = this.currentQueryTotal; + context.parentContext = this; + this.subContextCount++; + return context; + }; + /** + * @param {?=} newTime + * @return {?} + */ + 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); + return this.currentTimeline; + }; + /** + * @param {?} instruction + * @param {?} duration + * @param {?} delay + * @return {?} + */ + 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(this._driver, instruction.element, instruction.keyframes, instruction.preStyleProps, instruction.postStyleProps, updatedTimings, instruction.stretchStartingKeyframe); + this.timelines.push(builder); + return updatedTimings; + }; + /** + * @param {?} time + * @return {?} + */ + AnimationTimelineContext.prototype.incrementTime = /** + * @param {?} time + * @return {?} + */ + function (time) { + this.currentTimeline.forwardTime(this.currentTimeline.duration + time); + }; + /** + * @param {?} delay + * @return {?} + */ + AnimationTimelineContext.prototype.delayNextStep = /** + * @param {?} delay + * @return {?} + */ + function (delay) { + // negative delays are not yet supported + if (delay > 0) { + this.currentTimeline.delayNextStep(delay); + } + }; + /** + * @param {?} selector + * @param {?} originalSelector + * @param {?} limit + * @param {?} includeSelf + * @param {?} optional + * @param {?} errors + * @return {?} + */ + 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 = limit < 0 ? elements.slice(elements.length + limit, elements.length) : + elements.slice(0, limit); + } + results.push.apply(results, elements); + } + if (!optional && results.length == 0) { + errors.push("`query(\"" + originalSelector + "\")` returned zero elements. (Use `query(\"" + originalSelector + "\", { optional: true })` if you wish to allow this.)"); + } + return results; + }; + return AnimationTimelineContext; +}()); +var TimelineBuilder = /** @class */ (function () { + function TimelineBuilder(_driver, element, startTime, _elementTimelineStylesLookup) { + this._driver = _driver; + this.element = element; + this.startTime = startTime; + this._elementTimelineStylesLookup = _elementTimelineStylesLookup; + this.duration = 0; + this._previousKeyframe = {}; + this._currentKeyframe = {}; + this._keyframes = new Map(); + this._styleSummary = {}; + this._pendingStyles = {}; + this._backFill = {}; + this._currentEmptyStepKeyframe = null; + if (!this._elementTimelineStylesLookup) { + this._elementTimelineStylesLookup = new Map(); + } + this._localTimelineStyles = Object.create(this._backFill, {}); + this._globalTimelineStyles = /** @type {?} */ ((this._elementTimelineStylesLookup.get(element))); + if (!this._globalTimelineStyles) { + this._globalTimelineStyles = this._localTimelineStyles; + this._elementTimelineStylesLookup.set(element, this._localTimelineStyles); + } + this._loadKeyframe(); + } + /** + * @return {?} + */ + TimelineBuilder.prototype.containsAnimation = /** + * @return {?} + */ + function () { + switch (this._keyframes.size) { + case 0: + return false; + case 1: + return this.getCurrentStyleProperties().length > 0; + default: + return true; + } + }; + /** + * @return {?} + */ + TimelineBuilder.prototype.getCurrentStyleProperties = /** + * @return {?} + */ + function () { return Object.keys(this._currentKeyframe); }; + Object.defineProperty(TimelineBuilder.prototype, "currentTime", { + get: /** + * @return {?} + */ + function () { return this.startTime + this.duration; }, + enumerable: true, + configurable: true + }); + /** + * @param {?} delay + * @return {?} + */ + 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 + // properly applies the style() values to work with the stagger... + var /** @type {?} */ hasPreStyleStep = this._keyframes.size == 1 && Object.keys(this._pendingStyles).length; + if (this.duration || hasPreStyleStep) { + this.forwardTime(this.currentTime + delay); + if (hasPreStyleStep) { + this.snapshotCurrentStyles(); + } + } + else { + this.startTime += delay; + } + }; + /** + * @param {?} element + * @param {?=} currentTime + * @return {?} + */ + TimelineBuilder.prototype.fork = /** + * @param {?} element + * @param {?=} currentTime + * @return {?} + */ + function (element, currentTime) { + this.applyStylesToKeyframe(); + return new TimelineBuilder(this._driver, element, currentTime || this.currentTime, this._elementTimelineStylesLookup); + }; + /** + * @return {?} + */ + TimelineBuilder.prototype._loadKeyframe = /** + * @return {?} + */ + function () { + if (this._currentKeyframe) { + this._previousKeyframe = this._currentKeyframe; + } + this._currentKeyframe = /** @type {?} */ ((this._keyframes.get(this.duration))); + if (!this._currentKeyframe) { + this._currentKeyframe = Object.create(this._backFill, {}); + this._keyframes.set(this.duration, this._currentKeyframe); + } + }; + /** + * @return {?} + */ + TimelineBuilder.prototype.forwardFrame = /** + * @return {?} + */ + function () { + this.duration += ONE_FRAME_IN_MILLISECONDS; + this._loadKeyframe(); + }; + /** + * @param {?} time + * @return {?} + */ + TimelineBuilder.prototype.forwardTime = /** + * @param {?} time + * @return {?} + */ + function (time) { + this.applyStylesToKeyframe(); + this.duration = time; + this._loadKeyframe(); + }; + /** + * @param {?} prop + * @param {?} value + * @return {?} + */ + 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 }; + }; + /** + * @return {?} + */ + TimelineBuilder.prototype.allowOnlyTimelineStyles = /** + * @return {?} + */ + function () { return this._currentEmptyStepKeyframe !== this._currentKeyframe; }; + /** + * @param {?} easing + * @return {?} + */ + TimelineBuilder.prototype.applyEmptyStep = /** + * @param {?} easing + * @return {?} + */ + function (easing) { + var _this = this; + if (easing) { + this._previousKeyframe['easing'] = easing; + } + // special case for animate(duration): + // all missing styles are filled with a `*` value then + // if any destination styles are filled in later on the same + // keyframe then they will override the overridden styles + // We use `_globalTimelineStyles` here because there may be + // styles in previous keyframes that are not present in this timeline + Object.keys(this._globalTimelineStyles).forEach(function (prop) { + _this._backFill[prop] = _this._globalTimelineStyles[prop] || AUTO_STYLE; + _this._currentKeyframe[prop] = AUTO_STYLE; + }); + this._currentEmptyStepKeyframe = this._currentKeyframe; + }; + /** + * @param {?} input + * @param {?} easing + * @param {?} errors + * @param {?=} options + * @return {?} + */ + 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; + } + var /** @type {?} */ params = (options && options.params) || {}; + var /** @type {?} */ styles = flattenStyles(input, this._globalTimelineStyles); + Object.keys(styles).forEach(function (prop) { + var /** @type {?} */ val = interpolateParams(styles[prop], params, errors); + _this._pendingStyles[prop] = val; + if (!_this._localTimelineStyles.hasOwnProperty(prop)) { + _this._backFill[prop] = _this._globalTimelineStyles.hasOwnProperty(prop) ? + _this._globalTimelineStyles[prop] : + AUTO_STYLE; + } + _this._updateStyle(prop, val); + }); + }; + /** + * @return {?} + */ + TimelineBuilder.prototype.applyStylesToKeyframe = /** + * @return {?} + */ + function () { + var _this = this; + var /** @type {?} */ styles = this._pendingStyles; + var /** @type {?} */ props = Object.keys(styles); + if (props.length == 0) + return; + this._pendingStyles = {}; + props.forEach(function (prop) { + var /** @type {?} */ val = styles[prop]; + _this._currentKeyframe[prop] = val; + }); + Object.keys(this._localTimelineStyles).forEach(function (prop) { + if (!_this._currentKeyframe.hasOwnProperty(prop)) { + _this._currentKeyframe[prop] = _this._localTimelineStyles[prop]; + } + }); + }; + /** + * @return {?} + */ + TimelineBuilder.prototype.snapshotCurrentStyles = /** + * @return {?} + */ + function () { + var _this = this; + Object.keys(this._localTimelineStyles).forEach(function (prop) { + var /** @type {?} */ val = _this._localTimelineStyles[prop]; + _this._pendingStyles[prop] = val; + _this._updateStyle(prop, val); + }); + }; + /** + * @return {?} + */ + TimelineBuilder.prototype.getFinalKeyframe = /** + * @return {?} + */ + function () { return this._keyframes.get(this.duration); }; + Object.defineProperty(TimelineBuilder.prototype, "properties", { + get: /** + * @return {?} + */ + function () { + var /** @type {?} */ properties = []; + for (var /** @type {?} */ prop in this._currentKeyframe) { + properties.push(prop); + } + return properties; + }, + enumerable: true, + configurable: true + }); + /** + * @param {?} timeline + * @return {?} + */ + T
<TRUNCATED>
