| /** |
| * @license AngularJS v1.3.0-beta.5 |
| * (c) 2010-2014 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| (function(window, angular, undefined) {'use strict'; |
| |
| /* jshint maxlen: false */ |
| |
| /** |
| * @ngdoc module |
| * @name ngAnimate |
| * @description |
| * |
| * The `ngAnimate` module provides support for JavaScript, CSS3 transition and CSS3 keyframe animation hooks within existing core and custom directives. |
| * |
| * <div doc-module-components="ngAnimate"></div> |
| * |
| * # Usage |
| * |
| * To see animations in action, all that is required is to define the appropriate CSS classes |
| * or to register a JavaScript animation via the myModule.animation() function. The directives that support animation automatically are: |
| * `ngRepeat`, `ngInclude`, `ngIf`, `ngSwitch`, `ngShow`, `ngHide`, `ngView` and `ngClass`. Custom directives can take advantage of animation |
| * by using the `$animate` service. |
| * |
| * Below is a more detailed breakdown of the supported animation events provided by pre-existing ng directives: |
| * |
| * | Directive | Supported Animations | |
| * |-----------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------| |
| * | {@link ng.directive:ngRepeat#usage_animations ngRepeat} | enter, leave and move | |
| * | {@link ngRoute.directive:ngView#usage_animations ngView} | enter and leave | |
| * | {@link ng.directive:ngInclude#usage_animations ngInclude} | enter and leave | |
| * | {@link ng.directive:ngSwitch#usage_animations ngSwitch} | enter and leave | |
| * | {@link ng.directive:ngIf#usage_animations ngIf} | enter and leave | |
| * | {@link ng.directive:ngClass#usage_animations ngClass} | add and remove (the CSS class(es) present) | |
| * | {@link ng.directive:ngShow#usage_animations ngShow} & {@link ng.directive:ngHide#usage_animations ngHide} | add and remove (the ng-hide class value) | |
| * | {@link ng.directive:form#usage_animations form} & {@link ng.directive:ngModel#usage_animations ngModel} | add and remove (dirty, pristine, valid, invalid & all other validations) | |
| * |
| * You can find out more information about animations upon visiting each directive page. |
| * |
| * Below is an example of how to apply animations to a directive that supports animation hooks: |
| * |
| * ```html |
| * <style type="text/css"> |
| * .slide.ng-enter, .slide.ng-leave { |
| * -webkit-transition:0.5s linear all; |
| * transition:0.5s linear all; |
| * } |
| * |
| * .slide.ng-enter { } /* starting animations for enter */ |
| * .slide.ng-enter-active { } /* terminal animations for enter */ |
| * .slide.ng-leave { } /* starting animations for leave */ |
| * .slide.ng-leave-active { } /* terminal animations for leave */ |
| * </style> |
| * |
| * <!-- |
| * the animate service will automatically add .ng-enter and .ng-leave to the element |
| * to trigger the CSS transition/animations |
| * --> |
| * <ANY class="slide" ng-include="..."></ANY> |
| * ``` |
| * |
| * Keep in mind that if an animation is running, any child elements cannot be animated until the parent element's |
| * animation has completed. |
| * |
| * <h2>CSS-defined Animations</h2> |
| * The animate service will automatically apply two CSS classes to the animated element and these two CSS classes |
| * are designed to contain the start and end CSS styling. Both CSS transitions and keyframe animations are supported |
| * and can be used to play along with this naming structure. |
| * |
| * The following code below demonstrates how to perform animations using **CSS transitions** with Angular: |
| * |
| * ```html |
| * <style type="text/css"> |
| * /* |
| * The animate class is apart of the element and the ng-enter class |
| * is attached to the element once the enter animation event is triggered |
| * */ |
| * .reveal-animation.ng-enter { |
| * -webkit-transition: 1s linear all; /* Safari/Chrome */ |
| * transition: 1s linear all; /* All other modern browsers and IE10+ */ |
| * |
| * /* The animation preparation code */ |
| * opacity: 0; |
| * } |
| * |
| * /* |
| * Keep in mind that you want to combine both CSS |
| * classes together to avoid any CSS-specificity |
| * conflicts |
| * */ |
| * .reveal-animation.ng-enter.ng-enter-active { |
| * /* The animation code itself */ |
| * opacity: 1; |
| * } |
| * </style> |
| * |
| * <div class="view-container"> |
| * <div ng-view class="reveal-animation"></div> |
| * </div> |
| * ``` |
| * |
| * The following code below demonstrates how to perform animations using **CSS animations** with Angular: |
| * |
| * ```html |
| * <style type="text/css"> |
| * .reveal-animation.ng-enter { |
| * -webkit-animation: enter_sequence 1s linear; /* Safari/Chrome */ |
| * animation: enter_sequence 1s linear; /* IE10+ and Future Browsers */ |
| * } |
| * @-webkit-keyframes enter_sequence { |
| * from { opacity:0; } |
| * to { opacity:1; } |
| * } |
| * @keyframes enter_sequence { |
| * from { opacity:0; } |
| * to { opacity:1; } |
| * } |
| * </style> |
| * |
| * <div class="view-container"> |
| * <div ng-view class="reveal-animation"></div> |
| * </div> |
| * ``` |
| * |
| * Both CSS3 animations and transitions can be used together and the animate service will figure out the correct duration and delay timing. |
| * |
| * Upon DOM mutation, the event class is added first (something like `ng-enter`), then the browser prepares itself to add |
| * the active class (in this case `ng-enter-active`) which then triggers the animation. The animation module will automatically |
| * detect the CSS code to determine when the animation ends. Once the animation is over then both CSS classes will be |
| * removed from the DOM. If a browser does not support CSS transitions or CSS animations then the animation will start and end |
| * immediately resulting in a DOM element that is at its final state. This final state is when the DOM element |
| * has no CSS transition/animation classes applied to it. |
| * |
| * ### Structural transition animations |
| * |
| * Structural transitions (such as enter, leave and move) will always apply a `0s none` transition |
| * value to force the browser into rendering the styles defined in the setup (.ng-enter, .ng-leave |
| * or .ng-move) class. This means that any active transition animations operating on the element |
| * will be cut off to make way for the enter, leave or move animation. |
| * |
| * ### Class-based transition animations |
| * |
| * Class-based transitions refer to transition animations that are triggered when a CSS class is |
| * added to or removed from the element (via `$animate.addClass`, `$animate.removeClass`, |
| * `$animate.setClass`, or by directives such as `ngClass`, `ngModel` and `form`). |
| * They are different when compared to structural animations since they **do not cancel existing |
| * animations** nor do they **block successive transitions** from rendering on the same element. |
| * This distinction allows for **multiple class-based transitions** to be performed on the same element. |
| * |
| * In addition to ngAnimate supporting the default (natural) functionality of class-based transition |
| * animations, ngAnimate also decorates the element with starting and ending CSS classes to aid the |
| * developer in further styling the element throughout the transition animation. Earlier versions |
| * of ngAnimate may have caused natural CSS transitions to break and not render properly due to |
| * $animate temporarily blocking transitions using `0s none` in order to allow the setup CSS class |
| * (the `-add` or `-remove` class) to be applied without triggering an animation. However, as of |
| * **version 1.3**, this workaround has been removed with ngAnimate and all non-ngAnimate CSS |
| * class transitions are compatible with ngAnimate. |
| * |
| * There is, however, one special case when dealing with class-based transitions in ngAnimate. |
| * When rendering class-based transitions that make use of the setup and active CSS classes |
| * (e.g. `.fade-add` and `.fade-add-active` for when `.fade` is added) be sure to define |
| * the transition value **on the active CSS class** and not the setup class. |
| * |
| * ```css |
| * .fade-add { |
| * /* remember to place a 0s transition here |
| * to ensure that the styles are applied instantly |
| * even if the element already has a transition style */ |
| * transition:0s linear all; |
| * |
| * /* starting CSS styles */ |
| * opacity:1; |
| * } |
| * .fade-add.fade-add-active { |
| * /* this will be the length of the animation */ |
| * transition:1s linear all; |
| * opacity:0; |
| * } |
| * ``` |
| * |
| * The setup CSS class (in this case `.fade-add`) also has a transition style property, however, it |
| * has a duration of zero. This may not be required, however, incase the browser is unable to render |
| * the styling present in this CSS class instantly then it could be that the browser is attempting |
| * to perform an unnecessary transition. |
| * |
| * This workaround, however, does not apply to standard class-based transitions that are rendered |
| * when a CSS class containing a transition is applied to an element: |
| * |
| * ```css |
| * .fade { |
| * /* this works as expected */ |
| * transition:1s linear all; |
| * opacity:0; |
| * } |
| * ``` |
| * |
| * Please keep this in mind when coding the CSS markup that will be used within class-based transitions. |
| * Also, try not to mix the two class-based animation flavors together since the CSS code may become |
| * overly complex. |
| * |
| * ### CSS Staggering Animations |
| * A Staggering animation is a collection of animations that are issued with a slight delay in between each successive operation resulting in a |
| * curtain-like effect. The ngAnimate module, as of 1.2.0, supports staggering animations and the stagger effect can be |
| * performed by creating a **ng-EVENT-stagger** CSS class and attaching that class to the base CSS class used for |
| * the animation. The style property expected within the stagger class can either be a **transition-delay** or an |
| * **animation-delay** property (or both if your animation contains both transitions and keyframe animations). |
| * |
| * ```css |
| * .my-animation.ng-enter { |
| * /* standard transition code */ |
| * -webkit-transition: 1s linear all; |
| * transition: 1s linear all; |
| * opacity:0; |
| * } |
| * .my-animation.ng-enter-stagger { |
| * /* this will have a 100ms delay between each successive leave animation */ |
| * -webkit-transition-delay: 0.1s; |
| * transition-delay: 0.1s; |
| * |
| * /* in case the stagger doesn't work then these two values |
| * must be set to 0 to avoid an accidental CSS inheritance */ |
| * -webkit-transition-duration: 0s; |
| * transition-duration: 0s; |
| * } |
| * .my-animation.ng-enter.ng-enter-active { |
| * /* standard transition styles */ |
| * opacity:1; |
| * } |
| * ``` |
| * |
| * Staggering animations work by default in ngRepeat (so long as the CSS class is defined). Outside of ngRepeat, to use staggering animations |
| * on your own, they can be triggered by firing multiple calls to the same event on $animate. However, the restrictions surrounding this |
| * are that each of the elements must have the same CSS className value as well as the same parent element. A stagger operation |
| * will also be reset if more than 10ms has passed after the last animation has been fired. |
| * |
| * The following code will issue the **ng-leave-stagger** event on the element provided: |
| * |
| * ```js |
| * var kids = parent.children(); |
| * |
| * $animate.leave(kids[0]); //stagger index=0 |
| * $animate.leave(kids[1]); //stagger index=1 |
| * $animate.leave(kids[2]); //stagger index=2 |
| * $animate.leave(kids[3]); //stagger index=3 |
| * $animate.leave(kids[4]); //stagger index=4 |
| * |
| * $timeout(function() { |
| * //stagger has reset itself |
| * $animate.leave(kids[5]); //stagger index=0 |
| * $animate.leave(kids[6]); //stagger index=1 |
| * }, 100, false); |
| * ``` |
| * |
| * Stagger animations are currently only supported within CSS-defined animations. |
| * |
| * <h2>JavaScript-defined Animations</h2> |
| * In the event that you do not want to use CSS3 transitions or CSS3 animations or if you wish to offer animations on browsers that do not |
| * yet support CSS transitions/animations, then you can make use of JavaScript animations defined inside of your AngularJS module. |
| * |
| * ```js |
| * //!annotate="YourApp" Your AngularJS Module|Replace this or ngModule with the module that you used to define your application. |
| * var ngModule = angular.module('YourApp', ['ngAnimate']); |
| * ngModule.animation('.my-crazy-animation', function() { |
| * return { |
| * enter: function(element, done) { |
| * //run the animation here and call done when the animation is complete |
| * return function(cancelled) { |
| * //this (optional) function will be called when the animation |
| * //completes or when the animation is cancelled (the cancelled |
| * //flag will be set to true if cancelled). |
| * }; |
| * }, |
| * leave: function(element, done) { }, |
| * move: function(element, done) { }, |
| * |
| * //animation that can be triggered before the class is added |
| * beforeAddClass: function(element, className, done) { }, |
| * |
| * //animation that can be triggered after the class is added |
| * addClass: function(element, className, done) { }, |
| * |
| * //animation that can be triggered before the class is removed |
| * beforeRemoveClass: function(element, className, done) { }, |
| * |
| * //animation that can be triggered after the class is removed |
| * removeClass: function(element, className, done) { } |
| * }; |
| * }); |
| * ``` |
| * |
| * JavaScript-defined animations are created with a CSS-like class selector and a collection of events which are set to run |
| * a javascript callback function. When an animation is triggered, $animate will look for a matching animation which fits |
| * the element's CSS class attribute value and then run the matching animation event function (if found). |
| * In other words, if the CSS classes present on the animated element match any of the JavaScript animations then the callback function will |
| * be executed. It should be also noted that only simple, single class selectors are allowed (compound class selectors are not supported). |
| * |
| * Within a JavaScript animation, an object containing various event callback animation functions is expected to be returned. |
| * As explained above, these callbacks are triggered based on the animation event. Therefore if an enter animation is run, |
| * and the JavaScript animation is found, then the enter callback will handle that animation (in addition to the CSS keyframe animation |
| * or transition code that is defined via a stylesheet). |
| * |
| */ |
| |
| angular.module('ngAnimate', ['ng']) |
| |
| /** |
| * @ngdoc provider |
| * @name $animateProvider |
| * @description |
| * |
| * The `$animateProvider` allows developers to register JavaScript animation event handlers directly inside of a module. |
| * When an animation is triggered, the $animate service will query the $animate service to find any animations that match |
| * the provided name value. |
| * |
| * Requires the {@link ngAnimate `ngAnimate`} module to be installed. |
| * |
| * Please visit the {@link ngAnimate `ngAnimate`} module overview page learn more about how to use animations in your application. |
| * |
| */ |
| |
| //this private service is only used within CSS-enabled animations |
| //IE8 + IE9 do not support rAF natively, but that is fine since they |
| //also don't support transitions and keyframes which means that the code |
| //below will never be used by the two browsers. |
| .factory('$$animateReflow', ['$$rAF', '$document', function($$rAF, $document) { |
| var bod = $document[0].body; |
| return function(fn) { |
| //the returned function acts as the cancellation function |
| return $$rAF(function() { |
| //the line below will force the browser to perform a repaint |
| //so that all the animated elements within the animation frame |
| //will be properly updated and drawn on screen. This is |
| //required to perform multi-class CSS based animations with |
| //Firefox. DO NOT REMOVE THIS LINE. |
| var a = bod.offsetWidth + 1; |
| fn(); |
| }); |
| }; |
| }]) |
| |
| .config(['$provide', '$animateProvider', function($provide, $animateProvider) { |
| var noop = angular.noop; |
| var forEach = angular.forEach; |
| var selectors = $animateProvider.$$selectors; |
| |
| var ELEMENT_NODE = 1; |
| var NG_ANIMATE_STATE = '$$ngAnimateState'; |
| var NG_ANIMATE_CLASS_NAME = 'ng-animate'; |
| var rootAnimateState = {running: true}; |
| |
| function extractElementNode(element) { |
| for(var i = 0; i < element.length; i++) { |
| var elm = element[i]; |
| if(elm.nodeType == ELEMENT_NODE) { |
| return elm; |
| } |
| } |
| } |
| |
| function stripCommentsFromElement(element) { |
| return angular.element(extractElementNode(element)); |
| } |
| |
| function isMatchingElement(elm1, elm2) { |
| return extractElementNode(elm1) == extractElementNode(elm2); |
| } |
| |
| $provide.decorator('$animate', ['$delegate', '$injector', '$sniffer', '$rootElement', '$$asyncCallback', '$rootScope', '$document', |
| function($delegate, $injector, $sniffer, $rootElement, $$asyncCallback, $rootScope, $document) { |
| |
| var globalAnimationCounter = 0; |
| $rootElement.data(NG_ANIMATE_STATE, rootAnimateState); |
| |
| // disable animations during bootstrap, but once we bootstrapped, wait again |
| // for another digest until enabling animations. The reason why we digest twice |
| // is because all structural animations (enter, leave and move) all perform a |
| // post digest operation before animating. If we only wait for a single digest |
| // to pass then the structural animation would render its animation on page load. |
| // (which is what we're trying to avoid when the application first boots up.) |
| $rootScope.$$postDigest(function() { |
| $rootScope.$$postDigest(function() { |
| rootAnimateState.running = false; |
| }); |
| }); |
| |
| var classNameFilter = $animateProvider.classNameFilter(); |
| var isAnimatableClassName = !classNameFilter |
| ? function() { return true; } |
| : function(className) { |
| return classNameFilter.test(className); |
| }; |
| |
| function lookup(name) { |
| if (name) { |
| var matches = [], |
| flagMap = {}, |
| classes = name.substr(1).split('.'); |
| |
| //the empty string value is the default animation |
| //operation which performs CSS transition and keyframe |
| //animations sniffing. This is always included for each |
| //element animation procedure if the browser supports |
| //transitions and/or keyframe animations. The default |
| //animation is added to the top of the list to prevent |
| //any previous animations from affecting the element styling |
| //prior to the element being animated. |
| if ($sniffer.transitions || $sniffer.animations) { |
| matches.push($injector.get(selectors[''])); |
| } |
| |
| for(var i=0; i < classes.length; i++) { |
| var klass = classes[i], |
| selectorFactoryName = selectors[klass]; |
| if(selectorFactoryName && !flagMap[klass]) { |
| matches.push($injector.get(selectorFactoryName)); |
| flagMap[klass] = true; |
| } |
| } |
| return matches; |
| } |
| } |
| |
| function animationRunner(element, animationEvent, className) { |
| //transcluded directives may sometimes fire an animation using only comment nodes |
| //best to catch this early on to prevent any animation operations from occurring |
| var node = element[0]; |
| if(!node) { |
| return; |
| } |
| |
| var isSetClassOperation = animationEvent == 'setClass'; |
| var isClassBased = isSetClassOperation || |
| animationEvent == 'addClass' || |
| animationEvent == 'removeClass'; |
| |
| var classNameAdd, classNameRemove; |
| if(angular.isArray(className)) { |
| classNameAdd = className[0]; |
| classNameRemove = className[1]; |
| className = classNameAdd + ' ' + classNameRemove; |
| } |
| |
| var currentClassName = element.attr('class'); |
| var classes = currentClassName + ' ' + className; |
| if(!isAnimatableClassName(classes)) { |
| return; |
| } |
| |
| var beforeComplete = noop, |
| beforeCancel = [], |
| before = [], |
| afterComplete = noop, |
| afterCancel = [], |
| after = []; |
| |
| var animationLookup = (' ' + classes).replace(/\s+/g,'.'); |
| forEach(lookup(animationLookup), function(animationFactory) { |
| var created = registerAnimation(animationFactory, animationEvent); |
| if(!created && isSetClassOperation) { |
| registerAnimation(animationFactory, 'addClass'); |
| registerAnimation(animationFactory, 'removeClass'); |
| } |
| }); |
| |
| function registerAnimation(animationFactory, event) { |
| var afterFn = animationFactory[event]; |
| var beforeFn = animationFactory['before' + event.charAt(0).toUpperCase() + event.substr(1)]; |
| if(afterFn || beforeFn) { |
| if(event == 'leave') { |
| beforeFn = afterFn; |
| //when set as null then animation knows to skip this phase |
| afterFn = null; |
| } |
| after.push({ |
| event : event, fn : afterFn |
| }); |
| before.push({ |
| event : event, fn : beforeFn |
| }); |
| return true; |
| } |
| } |
| |
| function run(fns, cancellations, allCompleteFn) { |
| var animations = []; |
| forEach(fns, function(animation) { |
| animation.fn && animations.push(animation); |
| }); |
| |
| var count = 0; |
| function afterAnimationComplete(index) { |
| if(cancellations) { |
| (cancellations[index] || noop)(); |
| if(++count < animations.length) return; |
| cancellations = null; |
| } |
| allCompleteFn(); |
| } |
| |
| //The code below adds directly to the array in order to work with |
| //both sync and async animations. Sync animations are when the done() |
| //operation is called right away. DO NOT REFACTOR! |
| forEach(animations, function(animation, index) { |
| var progress = function() { |
| afterAnimationComplete(index); |
| }; |
| switch(animation.event) { |
| case 'setClass': |
| cancellations.push(animation.fn(element, classNameAdd, classNameRemove, progress)); |
| break; |
| case 'addClass': |
| cancellations.push(animation.fn(element, classNameAdd || className, progress)); |
| break; |
| case 'removeClass': |
| cancellations.push(animation.fn(element, classNameRemove || className, progress)); |
| break; |
| default: |
| cancellations.push(animation.fn(element, progress)); |
| break; |
| } |
| }); |
| |
| if(cancellations && cancellations.length === 0) { |
| allCompleteFn(); |
| } |
| } |
| |
| return { |
| node : node, |
| event : animationEvent, |
| className : className, |
| isClassBased : isClassBased, |
| isSetClassOperation : isSetClassOperation, |
| before : function(allCompleteFn) { |
| beforeComplete = allCompleteFn; |
| run(before, beforeCancel, function() { |
| beforeComplete = noop; |
| allCompleteFn(); |
| }); |
| }, |
| after : function(allCompleteFn) { |
| afterComplete = allCompleteFn; |
| run(after, afterCancel, function() { |
| afterComplete = noop; |
| allCompleteFn(); |
| }); |
| }, |
| cancel : function() { |
| if(beforeCancel) { |
| forEach(beforeCancel, function(cancelFn) { |
| (cancelFn || noop)(true); |
| }); |
| beforeComplete(true); |
| } |
| if(afterCancel) { |
| forEach(afterCancel, function(cancelFn) { |
| (cancelFn || noop)(true); |
| }); |
| afterComplete(true); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $animate |
| * @function |
| * |
| * @description |
| * The `$animate` service provides animation detection support while performing DOM operations (enter, leave and move) as well as during addClass and removeClass operations. |
| * When any of these operations are run, the $animate service |
| * will examine any JavaScript-defined animations (which are defined by using the $animateProvider provider object) |
| * as well as any CSS-defined animations against the CSS classes present on the element once the DOM operation is run. |
| * |
| * The `$animate` service is used behind the scenes with pre-existing directives and animation with these directives |
| * will work out of the box without any extra configuration. |
| * |
| * Requires the {@link ngAnimate `ngAnimate`} module to be installed. |
| * |
| * Please visit the {@link ngAnimate `ngAnimate`} module overview page learn more about how to use animations in your application. |
| * |
| */ |
| return { |
| /** |
| * @ngdoc method |
| * @name $animate#enter |
| * @function |
| * |
| * @description |
| * Appends the element to the parentElement element that resides in the document and then runs the enter animation. Once |
| * the animation is started, the following CSS classes will be present on the element for the duration of the animation: |
| * |
| * Below is a breakdown of each step that occurs during enter animation: |
| * |
| * | Animation Step | What the element class attribute looks like | |
| * |-------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------| |
| * | 1. $animate.enter(...) is called | class="my-animation" | |
| * | 2. element is inserted into the parentElement element or beside the afterElement element | class="my-animation" | |
| * | 3. $animate waits for the next digest to start the animation | class="my-animation ng-animate" | |
| * | 4. $animate runs the JavaScript-defined animations detected on the element | class="my-animation ng-animate" | |
| * | 5. the .ng-enter class is added to the element | class="my-animation ng-animate ng-enter" | |
| * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay | class="my-animation ng-animate ng-enter" | |
| * | 7. $animate blocks all CSS transitions on the element to ensure the .ng-enter class styling is applied right away | class="my-animation ng-animate ng-enter" | |
| * | 8. $animate waits for a single animation frame (this performs a reflow) | class="my-animation ng-animate ng-enter" | |
| * | 9. $animate removes the CSS transition block placed on the element | class="my-animation ng-animate ng-enter" | |
| * | 10. the .ng-enter-active class is added (this triggers the CSS transition/animation) | class="my-animation ng-animate ng-enter ng-enter-active" | |
| * | 11. $animate waits for the animation to complete (via events and timeout) | class="my-animation ng-animate ng-enter ng-enter-active" | |
| * | 12. The animation ends and all generated CSS classes are removed from the element | class="my-animation" | |
| * | 13. The doneCallback() callback is fired (if provided) | class="my-animation" | |
| * |
| * @param {DOMElement} element the element that will be the focus of the enter animation |
| * @param {DOMElement} parentElement the parent element of the element that will be the focus of the enter animation |
| * @param {DOMElement} afterElement the sibling element (which is the previous element) of the element that will be the focus of the enter animation |
| * @param {function()=} doneCallback the callback function that will be called once the animation is complete |
| */ |
| enter : function(element, parentElement, afterElement, doneCallback) { |
| this.enabled(false, element); |
| $delegate.enter(element, parentElement, afterElement); |
| $rootScope.$$postDigest(function() { |
| element = stripCommentsFromElement(element); |
| performAnimation('enter', 'ng-enter', element, parentElement, afterElement, noop, doneCallback); |
| }); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#leave |
| * @function |
| * |
| * @description |
| * Runs the leave animation operation and, upon completion, removes the element from the DOM. Once |
| * the animation is started, the following CSS classes will be added for the duration of the animation: |
| * |
| * Below is a breakdown of each step that occurs during leave animation: |
| * |
| * | Animation Step | What the element class attribute looks like | |
| * |-------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------| |
| * | 1. $animate.leave(...) is called | class="my-animation" | |
| * | 2. $animate runs the JavaScript-defined animations detected on the element | class="my-animation ng-animate" | |
| * | 3. $animate waits for the next digest to start the animation | class="my-animation ng-animate" | |
| * | 4. the .ng-leave class is added to the element | class="my-animation ng-animate ng-leave" | |
| * | 5. $animate scans the element styles to get the CSS transition/animation duration and delay | class="my-animation ng-animate ng-leave" | |
| * | 6. $animate blocks all CSS transitions on the element to ensure the .ng-leave class styling is applied right away | class="my-animation ng-animate ng-leave” | |
| * | 7. $animate waits for a single animation frame (this performs a reflow) | class="my-animation ng-animate ng-leave" | |
| * | 8. $animate removes the CSS transition block placed on the element | class="my-animation ng-animate ng-leave” | |
| * | 9. the .ng-leave-active class is added (this triggers the CSS transition/animation) | class="my-animation ng-animate ng-leave ng-leave-active" | |
| * | 10. $animate waits for the animation to complete (via events and timeout) | class="my-animation ng-animate ng-leave ng-leave-active" | |
| * | 11. The animation ends and all generated CSS classes are removed from the element | class="my-animation" | |
| * | 12. The element is removed from the DOM | ... | |
| * | 13. The doneCallback() callback is fired (if provided) | ... | |
| * |
| * @param {DOMElement} element the element that will be the focus of the leave animation |
| * @param {function()=} doneCallback the callback function that will be called once the animation is complete |
| */ |
| leave : function(element, doneCallback) { |
| cancelChildAnimations(element); |
| this.enabled(false, element); |
| $rootScope.$$postDigest(function() { |
| performAnimation('leave', 'ng-leave', stripCommentsFromElement(element), null, null, function() { |
| $delegate.leave(element); |
| }, doneCallback); |
| }); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#move |
| * @function |
| * |
| * @description |
| * Fires the move DOM operation. Just before the animation starts, the animate service will either append it into the parentElement container or |
| * add the element directly after the afterElement element if present. Then the move animation will be run. Once |
| * the animation is started, the following CSS classes will be added for the duration of the animation: |
| * |
| * Below is a breakdown of each step that occurs during move animation: |
| * |
| * | Animation Step | What the element class attribute looks like | |
| * |------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------| |
| * | 1. $animate.move(...) is called | class="my-animation" | |
| * | 2. element is moved into the parentElement element or beside the afterElement element | class="my-animation" | |
| * | 3. $animate waits for the next digest to start the animation | class="my-animation ng-animate" | |
| * | 4. $animate runs the JavaScript-defined animations detected on the element | class="my-animation ng-animate" | |
| * | 5. the .ng-move class is added to the element | class="my-animation ng-animate ng-move" | |
| * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay | class="my-animation ng-animate ng-move" | |
| * | 7. $animate blocks all CSS transitions on the element to ensure the .ng-move class styling is applied right away | class="my-animation ng-animate ng-move” | |
| * | 8. $animate waits for a single animation frame (this performs a reflow) | class="my-animation ng-animate ng-move" | |
| * | 9. $animate removes the CSS transition block placed on the element | class="my-animation ng-animate ng-move” | |
| * | 10. the .ng-move-active class is added (this triggers the CSS transition/animation) | class="my-animation ng-animate ng-move ng-move-active" | |
| * | 11. $animate waits for the animation to complete (via events and timeout) | class="my-animation ng-animate ng-move ng-move-active" | |
| * | 12. The animation ends and all generated CSS classes are removed from the element | class="my-animation" | |
| * | 13. The doneCallback() callback is fired (if provided) | class="my-animation" | |
| * |
| * @param {DOMElement} element the element that will be the focus of the move animation |
| * @param {DOMElement} parentElement the parentElement element of the element that will be the focus of the move animation |
| * @param {DOMElement} afterElement the sibling element (which is the previous element) of the element that will be the focus of the move animation |
| * @param {function()=} doneCallback the callback function that will be called once the animation is complete |
| */ |
| move : function(element, parentElement, afterElement, doneCallback) { |
| cancelChildAnimations(element); |
| this.enabled(false, element); |
| $delegate.move(element, parentElement, afterElement); |
| $rootScope.$$postDigest(function() { |
| element = stripCommentsFromElement(element); |
| performAnimation('move', 'ng-move', element, parentElement, afterElement, noop, doneCallback); |
| }); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#addClass |
| * |
| * @description |
| * Triggers a custom animation event based off the className variable and then attaches the className value to the element as a CSS class. |
| * Unlike the other animation methods, the animate service will suffix the className value with {@type -add} in order to provide |
| * the animate service the setup and active CSS classes in order to trigger the animation (this will be skipped if no CSS transitions |
| * or keyframes are defined on the -add-active or base CSS class). |
| * |
| * Below is a breakdown of each step that occurs during addClass animation: |
| * |
| * | Animation Step | What the element class attribute looks like | |
| * |----------------------------------------------------------------------------------------------------|------------------------------------------------------------------| |
| * | 1. $animate.addClass(element, 'super') is called | class="my-animation" | |
| * | 2. $animate runs the JavaScript-defined animations detected on the element | class="my-animation ng-animate" | |
| * | 3. the .super-add class is added to the element | class="my-animation ng-animate super-add" | |
| * | 4. $animate waits for a single animation frame (this performs a reflow) | class="my-animation ng-animate super-add" | |
| * | 5. the .super and .super-add-active classes are added (this triggers the CSS transition/animation) | class="my-animation ng-animate super super-add super-add-active" | |
| * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay | class="my-animation ng-animate super-add" | |
| * | 7. $animate waits for the animation to complete (via events and timeout) | class="my-animation super super-add super-add-active" | |
| * | 8. The animation ends and all generated CSS classes are removed from the element | class="my-animation super" | |
| * | 9. The super class is kept on the element | class="my-animation super" | |
| * | 10. The doneCallback() callback is fired (if provided) | class="my-animation super" | |
| * |
| * @param {DOMElement} element the element that will be animated |
| * @param {string} className the CSS class that will be added to the element and then animated |
| * @param {function()=} doneCallback the callback function that will be called once the animation is complete |
| */ |
| addClass : function(element, className, doneCallback) { |
| element = stripCommentsFromElement(element); |
| performAnimation('addClass', className, element, null, null, function() { |
| $delegate.addClass(element, className); |
| }, doneCallback); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#removeClass |
| * |
| * @description |
| * Triggers a custom animation event based off the className variable and then removes the CSS class provided by the className value |
| * from the element. Unlike the other animation methods, the animate service will suffix the className value with {@type -remove} in |
| * order to provide the animate service the setup and active CSS classes in order to trigger the animation (this will be skipped if |
| * no CSS transitions or keyframes are defined on the -remove or base CSS classes). |
| * |
| * Below is a breakdown of each step that occurs during removeClass animation: |
| * |
| * | Animation Step | What the element class attribute looks like | |
| * |------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------| |
| * | 1. $animate.removeClass(element, 'super') is called | class="my-animation super" | |
| * | 2. $animate runs the JavaScript-defined animations detected on the element | class="my-animation super ng-animate" | |
| * | 3. the .super-remove class is added to the element | class="my-animation super ng-animate super-remove" | |
| * | 4. $animate waits for a single animation frame (this performs a reflow) | class="my-animation super ng-animate super-remove" | |
| * | 5. the .super-remove-active classes are added and .super is removed (this triggers the CSS transition/animation) | class="my-animation ng-animate super-remove super-remove-active" | |
| * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay | class="my-animation super ng-animate super-remove" | |
| * | 7. $animate waits for the animation to complete (via events and timeout) | class="my-animation ng-animate super-remove super-remove-active" | |
| * | 8. The animation ends and all generated CSS classes are removed from the element | class="my-animation" | |
| * | 9. The doneCallback() callback is fired (if provided) | class="my-animation" | |
| * |
| * |
| * @param {DOMElement} element the element that will be animated |
| * @param {string} className the CSS class that will be animated and then removed from the element |
| * @param {function()=} doneCallback the callback function that will be called once the animation is complete |
| */ |
| removeClass : function(element, className, doneCallback) { |
| element = stripCommentsFromElement(element); |
| performAnimation('removeClass', className, element, null, null, function() { |
| $delegate.removeClass(element, className); |
| }, doneCallback); |
| }, |
| |
| /** |
| * |
| * @ngdoc method |
| * @name $animate#setClass |
| * |
| * @description Adds and/or removes the given CSS classes to and from the element. |
| * Once complete, the done() callback will be fired (if provided). |
| * |
| * | Animation Step | What the element class attribute looks like | |
| * |--------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------| |
| * | 1. $animate.removeClass(element, ‘on’, ‘off’) is called | class="my-animation super off” | |
| * | 2. $animate runs the JavaScript-defined animations detected on the element | class="my-animation super ng-animate off” | |
| * | 3. the .on-add and .off-remove classes are added to the element | class="my-animation ng-animate on-add off-remove off” | |
| * | 4. $animate waits for a single animation frame (this performs a reflow) | class="my-animation ng-animate on-add off-remove off” | |
| * | 5. the .on, .on-add-active and .off-remove-active classes are added and .off is removed (this triggers the CSS transition/animation) | class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active” | |
| * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay | class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active" | |
| * | 7. $animate waits for the animation to complete (via events and timeout) | class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active" | |
| * | 8. The animation ends and all generated CSS classes are removed from the element | class="my-animation" | |
| * | 9. The doneCallback() callback is fired (if provided) | class="my-animation" | |
| * |
| * @param {DOMElement} element the element which will it's CSS classes changed |
| * removed from it |
| * @param {string} add the CSS classes which will be added to the element |
| * @param {string} remove the CSS class which will be removed from the element |
| * @param {Function=} done the callback function (if provided) that will be fired after the |
| * CSS classes have been set on the element |
| */ |
| setClass : function(element, add, remove, doneCallback) { |
| element = stripCommentsFromElement(element); |
| performAnimation('setClass', [add, remove], element, null, null, function() { |
| $delegate.setClass(element, add, remove); |
| }, doneCallback); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#enabled |
| * @function |
| * |
| * @param {boolean=} value If provided then set the animation on or off. |
| * @param {DOMElement=} element If provided then the element will be used to represent the enable/disable operation |
| * @return {boolean} Current animation state. |
| * |
| * @description |
| * Globally enables/disables animations. |
| * |
| */ |
| enabled : function(value, element) { |
| switch(arguments.length) { |
| case 2: |
| if(value) { |
| cleanup(element); |
| } else { |
| var data = element.data(NG_ANIMATE_STATE) || {}; |
| data.disabled = true; |
| element.data(NG_ANIMATE_STATE, data); |
| } |
| break; |
| |
| case 1: |
| rootAnimateState.disabled = !value; |
| break; |
| |
| default: |
| value = !rootAnimateState.disabled; |
| break; |
| } |
| return !!value; |
| } |
| }; |
| |
| /* |
| all animations call this shared animation triggering function internally. |
| The animationEvent variable refers to the JavaScript animation event that will be triggered |
| and the className value is the name of the animation that will be applied within the |
| CSS code. Element, parentElement and afterElement are provided DOM elements for the animation |
| and the onComplete callback will be fired once the animation is fully complete. |
| */ |
| function performAnimation(animationEvent, className, element, parentElement, afterElement, domOperation, doneCallback) { |
| |
| var runner = animationRunner(element, animationEvent, className); |
| if(!runner) { |
| fireDOMOperation(); |
| fireBeforeCallbackAsync(); |
| fireAfterCallbackAsync(); |
| closeAnimation(); |
| return; |
| } |
| |
| className = runner.className; |
| var elementEvents = angular.element._data(runner.node); |
| elementEvents = elementEvents && elementEvents.events; |
| |
| if (!parentElement) { |
| parentElement = afterElement ? afterElement.parent() : element.parent(); |
| } |
| |
| var ngAnimateState = element.data(NG_ANIMATE_STATE) || {}; |
| var runningAnimations = ngAnimateState.active || {}; |
| var totalActiveAnimations = ngAnimateState.totalActive || 0; |
| var lastAnimation = ngAnimateState.last; |
| |
| //only allow animations if the currently running animation is not structural |
| //or if there is no animation running at all |
| var skipAnimations = runner.isClassBased |
| ? ngAnimateState.disabled || (lastAnimation && !lastAnimation.isClassBased) |
| : false; |
| |
| //skip the animation if animations are disabled, a parent is already being animated, |
| //the element is not currently attached to the document body or then completely close |
| //the animation if any matching animations are not found at all. |
| //NOTE: IE8 + IE9 should close properly (run closeAnimation()) in case an animation was found. |
| if (skipAnimations || animationsDisabled(element, parentElement)) { |
| fireDOMOperation(); |
| fireBeforeCallbackAsync(); |
| fireAfterCallbackAsync(); |
| closeAnimation(); |
| return; |
| } |
| |
| var skipAnimation = false; |
| if(totalActiveAnimations > 0) { |
| var animationsToCancel = []; |
| if(!runner.isClassBased) { |
| if(animationEvent == 'leave' && runningAnimations['ng-leave']) { |
| skipAnimation = true; |
| } else { |
| //cancel all animations when a structural animation takes place |
| for(var klass in runningAnimations) { |
| animationsToCancel.push(runningAnimations[klass]); |
| cleanup(element, klass); |
| } |
| runningAnimations = {}; |
| totalActiveAnimations = 0; |
| } |
| } else if(lastAnimation.event == 'setClass') { |
| animationsToCancel.push(lastAnimation); |
| cleanup(element, className); |
| } |
| else if(runningAnimations[className]) { |
| var current = runningAnimations[className]; |
| if(current.event == animationEvent) { |
| skipAnimation = true; |
| } else { |
| animationsToCancel.push(current); |
| cleanup(element, className); |
| } |
| } |
| |
| if(animationsToCancel.length > 0) { |
| forEach(animationsToCancel, function(operation) { |
| operation.cancel(); |
| }); |
| } |
| } |
| |
| if(runner.isClassBased && !runner.isSetClassOperation && !skipAnimation) { |
| skipAnimation = (animationEvent == 'addClass') == element.hasClass(className); //opposite of XOR |
| } |
| |
| if(skipAnimation) { |
| fireBeforeCallbackAsync(); |
| fireAfterCallbackAsync(); |
| fireDoneCallbackAsync(); |
| return; |
| } |
| |
| if(animationEvent == 'leave') { |
| //there's no need to ever remove the listener since the element |
| //will be removed (destroyed) after the leave animation ends or |
| //is cancelled midway |
| element.one('$destroy', function(e) { |
| var element = angular.element(this); |
| var state = element.data(NG_ANIMATE_STATE); |
| if(state) { |
| var activeLeaveAnimation = state.active['ng-leave']; |
| if(activeLeaveAnimation) { |
| activeLeaveAnimation.cancel(); |
| cleanup(element, 'ng-leave'); |
| } |
| } |
| }); |
| } |
| |
| //the ng-animate class does nothing, but it's here to allow for |
| //parent animations to find and cancel child animations when needed |
| element.addClass(NG_ANIMATE_CLASS_NAME); |
| |
| var localAnimationCount = globalAnimationCounter++; |
| totalActiveAnimations++; |
| runningAnimations[className] = runner; |
| |
| element.data(NG_ANIMATE_STATE, { |
| last : runner, |
| active : runningAnimations, |
| index : localAnimationCount, |
| totalActive : totalActiveAnimations |
| }); |
| |
| //first we run the before animations and when all of those are complete |
| //then we perform the DOM operation and run the next set of animations |
| fireBeforeCallbackAsync(); |
| runner.before(function(cancelled) { |
| var data = element.data(NG_ANIMATE_STATE); |
| cancelled = cancelled || |
| !data || !data.active[className] || |
| (runner.isClassBased && data.active[className].event != animationEvent); |
| |
| fireDOMOperation(); |
| if(cancelled === true) { |
| closeAnimation(); |
| } else { |
| fireAfterCallbackAsync(); |
| runner.after(closeAnimation); |
| } |
| }); |
| |
| function fireDOMCallback(animationPhase) { |
| var eventName = '$animate:' + animationPhase; |
| if(elementEvents && elementEvents[eventName] && elementEvents[eventName].length > 0) { |
| $$asyncCallback(function() { |
| element.triggerHandler(eventName, { |
| event : animationEvent, |
| className : className |
| }); |
| }); |
| } |
| } |
| |
| function fireBeforeCallbackAsync() { |
| fireDOMCallback('before'); |
| } |
| |
| function fireAfterCallbackAsync() { |
| fireDOMCallback('after'); |
| } |
| |
| function fireDoneCallbackAsync() { |
| fireDOMCallback('close'); |
| if(doneCallback) { |
| $$asyncCallback(function() { |
| doneCallback(); |
| }); |
| } |
| } |
| |
| //it is less complicated to use a flag than managing and canceling |
| //timeouts containing multiple callbacks. |
| function fireDOMOperation() { |
| if(!fireDOMOperation.hasBeenRun) { |
| fireDOMOperation.hasBeenRun = true; |
| domOperation(); |
| } |
| } |
| |
| function closeAnimation() { |
| if(!closeAnimation.hasBeenRun) { |
| closeAnimation.hasBeenRun = true; |
| var data = element.data(NG_ANIMATE_STATE); |
| if(data) { |
| /* only structural animations wait for reflow before removing an |
| animation, but class-based animations don't. An example of this |
| failing would be when a parent HTML tag has a ng-class attribute |
| causing ALL directives below to skip animations during the digest */ |
| if(runner && runner.isClassBased) { |
| cleanup(element, className); |
| } else { |
| $$asyncCallback(function() { |
| var data = element.data(NG_ANIMATE_STATE) || {}; |
| if(localAnimationCount == data.index) { |
| cleanup(element, className, animationEvent); |
| } |
| }); |
| element.data(NG_ANIMATE_STATE, data); |
| } |
| } |
| fireDoneCallbackAsync(); |
| } |
| } |
| } |
| |
| function cancelChildAnimations(element) { |
| var node = extractElementNode(element); |
| if (node) { |
| var nodes = angular.isFunction(node.getElementsByClassName) ? |
| node.getElementsByClassName(NG_ANIMATE_CLASS_NAME) : |
| node.querySelectorAll('.' + NG_ANIMATE_CLASS_NAME); |
| forEach(nodes, function(element) { |
| element = angular.element(element); |
| var data = element.data(NG_ANIMATE_STATE); |
| if(data && data.active) { |
| forEach(data.active, function(runner) { |
| runner.cancel(); |
| }); |
| } |
| }); |
| } |
| } |
| |
| function cleanup(element, className) { |
| if(isMatchingElement(element, $rootElement)) { |
| if(!rootAnimateState.disabled) { |
| rootAnimateState.running = false; |
| rootAnimateState.structural = false; |
| } |
| } else if(className) { |
| var data = element.data(NG_ANIMATE_STATE) || {}; |
| |
| var removeAnimations = className === true; |
| if(!removeAnimations && data.active && data.active[className]) { |
| data.totalActive--; |
| delete data.active[className]; |
| } |
| |
| if(removeAnimations || !data.totalActive) { |
| element.removeClass(NG_ANIMATE_CLASS_NAME); |
| element.removeData(NG_ANIMATE_STATE); |
| } |
| } |
| } |
| |
| function animationsDisabled(element, parentElement) { |
| if (rootAnimateState.disabled) return true; |
| |
| if(isMatchingElement(element, $rootElement)) { |
| return rootAnimateState.disabled || rootAnimateState.running; |
| } |
| |
| do { |
| //the element did not reach the root element which means that it |
| //is not apart of the DOM. Therefore there is no reason to do |
| //any animations on it |
| if(parentElement.length === 0) break; |
| |
| var isRoot = isMatchingElement(parentElement, $rootElement); |
| var state = isRoot ? rootAnimateState : (parentElement.data(NG_ANIMATE_STATE) || {}); |
| var result = state.disabled || state.running |
| ? true |
| : state.last && !state.last.isClassBased; |
| |
| if(isRoot || result) { |
| return result; |
| } |
| |
| if(isRoot) return true; |
| } |
| while(parentElement = parentElement.parent()); |
| |
| return true; |
| } |
| }]); |
| |
| $animateProvider.register('', ['$window', '$sniffer', '$timeout', '$$animateReflow', |
| function($window, $sniffer, $timeout, $$animateReflow) { |
| // Detect proper transitionend/animationend event names. |
| var CSS_PREFIX = '', TRANSITION_PROP, TRANSITIONEND_EVENT, ANIMATION_PROP, ANIMATIONEND_EVENT; |
| |
| // If unprefixed events are not supported but webkit-prefixed are, use the latter. |
| // Otherwise, just use W3C names, browsers not supporting them at all will just ignore them. |
| // Note: Chrome implements `window.onwebkitanimationend` and doesn't implement `window.onanimationend` |
| // but at the same time dispatches the `animationend` event and not `webkitAnimationEnd`. |
| // Register both events in case `window.onanimationend` is not supported because of that, |
| // do the same for `transitionend` as Safari is likely to exhibit similar behavior. |
| // Also, the only modern browser that uses vendor prefixes for transitions/keyframes is webkit |
| // therefore there is no reason to test anymore for other vendor prefixes: http://caniuse.com/#search=transition |
| if (window.ontransitionend === undefined && window.onwebkittransitionend !== undefined) { |
| CSS_PREFIX = '-webkit-'; |
| TRANSITION_PROP = 'WebkitTransition'; |
| TRANSITIONEND_EVENT = 'webkitTransitionEnd transitionend'; |
| } else { |
| TRANSITION_PROP = 'transition'; |
| TRANSITIONEND_EVENT = 'transitionend'; |
| } |
| |
| if (window.onanimationend === undefined && window.onwebkitanimationend !== undefined) { |
| CSS_PREFIX = '-webkit-'; |
| ANIMATION_PROP = 'WebkitAnimation'; |
| ANIMATIONEND_EVENT = 'webkitAnimationEnd animationend'; |
| } else { |
| ANIMATION_PROP = 'animation'; |
| ANIMATIONEND_EVENT = 'animationend'; |
| } |
| |
| var DURATION_KEY = 'Duration'; |
| var PROPERTY_KEY = 'Property'; |
| var DELAY_KEY = 'Delay'; |
| var ANIMATION_ITERATION_COUNT_KEY = 'IterationCount'; |
| var NG_ANIMATE_PARENT_KEY = '$$ngAnimateKey'; |
| var NG_ANIMATE_CSS_DATA_KEY = '$$ngAnimateCSS3Data'; |
| var ELAPSED_TIME_MAX_DECIMAL_PLACES = 3; |
| var CLOSING_TIME_BUFFER = 1.5; |
| var ONE_SECOND = 1000; |
| |
| var lookupCache = {}; |
| var parentCounter = 0; |
| var animationReflowQueue = []; |
| var cancelAnimationReflow; |
| function afterReflow(element, callback) { |
| if(cancelAnimationReflow) { |
| cancelAnimationReflow(); |
| } |
| animationReflowQueue.push(callback); |
| cancelAnimationReflow = $$animateReflow(function() { |
| forEach(animationReflowQueue, function(fn) { |
| fn(); |
| }); |
| |
| animationReflowQueue = []; |
| cancelAnimationReflow = null; |
| lookupCache = {}; |
| }); |
| } |
| |
| var closingTimer = null; |
| var closingTimestamp = 0; |
| var animationElementQueue = []; |
| function animationCloseHandler(element, totalTime) { |
| var node = extractElementNode(element); |
| element = angular.element(node); |
| |
| //this item will be garbage collected by the closing |
| //animation timeout |
| animationElementQueue.push(element); |
| |
| //but it may not need to cancel out the existing timeout |
| //if the timestamp is less than the previous one |
| var futureTimestamp = Date.now() + totalTime; |
| if(futureTimestamp <= closingTimestamp) { |
| return; |
| } |
| |
| $timeout.cancel(closingTimer); |
| |
| closingTimestamp = futureTimestamp; |
| closingTimer = $timeout(function() { |
| closeAllAnimations(animationElementQueue); |
| animationElementQueue = []; |
| }, totalTime, false); |
| } |
| |
| function closeAllAnimations(elements) { |
| forEach(elements, function(element) { |
| var elementData = element.data(NG_ANIMATE_CSS_DATA_KEY); |
| if(elementData) { |
| (elementData.closeAnimationFn || noop)(); |
| } |
| }); |
| } |
| |
| function getElementAnimationDetails(element, cacheKey) { |
| var data = cacheKey ? lookupCache[cacheKey] : null; |
| if(!data) { |
| var transitionDuration = 0; |
| var transitionDelay = 0; |
| var animationDuration = 0; |
| var animationDelay = 0; |
| var transitionDelayStyle; |
| var animationDelayStyle; |
| var transitionDurationStyle; |
| var transitionPropertyStyle; |
| |
| //we want all the styles defined before and after |
| forEach(element, function(element) { |
| if (element.nodeType == ELEMENT_NODE) { |
| var elementStyles = $window.getComputedStyle(element) || {}; |
| |
| transitionDurationStyle = elementStyles[TRANSITION_PROP + DURATION_KEY]; |
| |
| transitionDuration = Math.max(parseMaxTime(transitionDurationStyle), transitionDuration); |
| |
| transitionPropertyStyle = elementStyles[TRANSITION_PROP + PROPERTY_KEY]; |
| |
| transitionDelayStyle = elementStyles[TRANSITION_PROP + DELAY_KEY]; |
| |
| transitionDelay = Math.max(parseMaxTime(transitionDelayStyle), transitionDelay); |
| |
| animationDelayStyle = elementStyles[ANIMATION_PROP + DELAY_KEY]; |
| |
| animationDelay = Math.max(parseMaxTime(animationDelayStyle), animationDelay); |
| |
| var aDuration = parseMaxTime(elementStyles[ANIMATION_PROP + DURATION_KEY]); |
| |
| if(aDuration > 0) { |
| aDuration *= parseInt(elementStyles[ANIMATION_PROP + ANIMATION_ITERATION_COUNT_KEY], 10) || 1; |
| } |
| |
| animationDuration = Math.max(aDuration, animationDuration); |
| } |
| }); |
| data = { |
| total : 0, |
| transitionPropertyStyle: transitionPropertyStyle, |
| transitionDurationStyle: transitionDurationStyle, |
| transitionDelayStyle: transitionDelayStyle, |
| transitionDelay: transitionDelay, |
| transitionDuration: transitionDuration, |
| animationDelayStyle: animationDelayStyle, |
| animationDelay: animationDelay, |
| animationDuration: animationDuration |
| }; |
| if(cacheKey) { |
| lookupCache[cacheKey] = data; |
| } |
| } |
| return data; |
| } |
| |
| function parseMaxTime(str) { |
| var maxValue = 0; |
| var values = angular.isString(str) ? |
| str.split(/\s*,\s*/) : |
| []; |
| forEach(values, function(value) { |
| maxValue = Math.max(parseFloat(value) || 0, maxValue); |
| }); |
| return maxValue; |
| } |
| |
| function getCacheKey(element) { |
| var parentElement = element.parent(); |
| var parentID = parentElement.data(NG_ANIMATE_PARENT_KEY); |
| if(!parentID) { |
| parentElement.data(NG_ANIMATE_PARENT_KEY, ++parentCounter); |
| parentID = parentCounter; |
| } |
| return parentID + '-' + extractElementNode(element).getAttribute('class'); |
| } |
| |
| function animateSetup(animationEvent, element, className) { |
| var structural = ['ng-enter','ng-leave','ng-move'].indexOf(className) >= 0; |
| |
| var cacheKey = getCacheKey(element); |
| var eventCacheKey = cacheKey + ' ' + className; |
| var itemIndex = lookupCache[eventCacheKey] ? ++lookupCache[eventCacheKey].total : 0; |
| |
| var stagger = {}; |
| if(itemIndex > 0) { |
| var staggerClassName = className + '-stagger'; |
| var staggerCacheKey = cacheKey + ' ' + staggerClassName; |
| var applyClasses = !lookupCache[staggerCacheKey]; |
| |
| applyClasses && element.addClass(staggerClassName); |
| |
| stagger = getElementAnimationDetails(element, staggerCacheKey); |
| |
| applyClasses && element.removeClass(staggerClassName); |
| } |
| |
| element.addClass(className); |
| |
| var formerData = element.data(NG_ANIMATE_CSS_DATA_KEY) || {}; |
| var timings = getElementAnimationDetails(element, eventCacheKey); |
| var transitionDuration = timings.transitionDuration; |
| var animationDuration = timings.animationDuration; |
| |
| if(structural && transitionDuration === 0 && animationDuration === 0) { |
| element.removeClass(className); |
| return false; |
| } |
| |
| var blockTransition = structural && transitionDuration > 0; |
| var blockAnimation = animationDuration > 0 && |
| stagger.animationDelay > 0 && |
| stagger.animationDuration === 0; |
| |
| element.data(NG_ANIMATE_CSS_DATA_KEY, { |
| stagger : stagger, |
| cacheKey : eventCacheKey, |
| running : formerData.running || 0, |
| itemIndex : itemIndex, |
| blockTransition : blockTransition, |
| blockAnimation : blockAnimation, |
| closeAnimationFn : noop |
| }); |
| |
| var node = extractElementNode(element); |
| |
| if(blockTransition) { |
| node.style[TRANSITION_PROP + PROPERTY_KEY] = 'none'; |
| } |
| |
| if(blockAnimation) { |
| node.style[ANIMATION_PROP] = 'none 0s'; |
| } |
| |
| return true; |
| } |
| |
| function animateRun(animationEvent, element, className, activeAnimationComplete) { |
| var node = extractElementNode(element); |
| var elementData = element.data(NG_ANIMATE_CSS_DATA_KEY); |
| if(node.getAttribute('class').indexOf(className) == -1 || !elementData) { |
| activeAnimationComplete(); |
| return; |
| } |
| |
| if(elementData.blockTransition) { |
| node.style[TRANSITION_PROP + PROPERTY_KEY] = ''; |
| } |
| |
| if(elementData.blockAnimation) { |
| node.style[ANIMATION_PROP] = ''; |
| } |
| |
| var activeClassName = ''; |
| forEach(className.split(' '), function(klass, i) { |
| activeClassName += (i > 0 ? ' ' : '') + klass + '-active'; |
| }); |
| |
| element.addClass(activeClassName); |
| var eventCacheKey = elementData.eventCacheKey + ' ' + activeClassName; |
| var timings = getElementAnimationDetails(element, eventCacheKey); |
| |
| var maxDuration = Math.max(timings.transitionDuration, timings.animationDuration); |
| if(maxDuration === 0) { |
| element.removeClass(activeClassName); |
| animateClose(element, className); |
| activeAnimationComplete(); |
| return; |
| } |
| |
| var maxDelay = Math.max(timings.transitionDelay, timings.animationDelay); |
| var stagger = elementData.stagger; |
| var itemIndex = elementData.itemIndex; |
| var maxDelayTime = maxDelay * ONE_SECOND; |
| |
| var style = '', appliedStyles = []; |
| if(timings.transitionDuration > 0) { |
| var propertyStyle = timings.transitionPropertyStyle; |
| if(propertyStyle.indexOf('all') == -1) { |
| style += CSS_PREFIX + 'transition-property: ' + propertyStyle + ';'; |
| style += CSS_PREFIX + 'transition-duration: ' + timings.transitionDurationStyle + ';'; |
| appliedStyles.push(CSS_PREFIX + 'transition-property'); |
| appliedStyles.push(CSS_PREFIX + 'transition-duration'); |
| } |
| } |
| |
| if(itemIndex > 0) { |
| if(stagger.transitionDelay > 0 && stagger.transitionDuration === 0) { |
| var delayStyle = timings.transitionDelayStyle; |
| style += CSS_PREFIX + 'transition-delay: ' + |
| prepareStaggerDelay(delayStyle, stagger.transitionDelay, itemIndex) + '; '; |
| appliedStyles.push(CSS_PREFIX + 'transition-delay'); |
| } |
| |
| if(stagger.animationDelay > 0 && stagger.animationDuration === 0) { |
| style += CSS_PREFIX + 'animation-delay: ' + |
| prepareStaggerDelay(timings.animationDelayStyle, stagger.animationDelay, itemIndex) + '; '; |
| appliedStyles.push(CSS_PREFIX + 'animation-delay'); |
| } |
| } |
| |
| if(appliedStyles.length > 0) { |
| //the element being animated may sometimes contain comment nodes in |
| //the jqLite object, so we're safe to use a single variable to house |
| //the styles since there is always only one element being animated |
| var oldStyle = node.getAttribute('style') || ''; |
| node.setAttribute('style', oldStyle + ' ' + style); |
| } |
| |
| var startTime = Date.now(); |
| var css3AnimationEvents = ANIMATIONEND_EVENT + ' ' + TRANSITIONEND_EVENT; |
| |
| element.on(css3AnimationEvents, onAnimationProgress); |
| elementData.closeAnimationFn = function() { |
| onEnd(); |
| activeAnimationComplete(); |
| }; |
| |
| var staggerTime = itemIndex * (Math.max(stagger.animationDelay, stagger.transitionDelay) || 0); |
| var animationTime = (maxDelay + maxDuration) * CLOSING_TIME_BUFFER; |
| var totalTime = (staggerTime + animationTime) * ONE_SECOND; |
| |
| elementData.running++; |
| animationCloseHandler(element, totalTime); |
| return onEnd; |
| |
| // This will automatically be called by $animate so |
| // there is no need to attach this internally to the |
| // timeout done method. |
| function onEnd(cancelled) { |
| element.off(css3AnimationEvents, onAnimationProgress); |
| element.removeClass(activeClassName); |
| animateClose(element, className); |
| var node = extractElementNode(element); |
| for (var i in appliedStyles) { |
| node.style.removeProperty(appliedStyles[i]); |
| } |
| } |
| |
| function onAnimationProgress(event) { |
| event.stopPropagation(); |
| var ev = event.originalEvent || event; |
| var timeStamp = ev.$manualTimeStamp || ev.timeStamp || Date.now(); |
| |
| /* Firefox (or possibly just Gecko) likes to not round values up |
| * when a ms measurement is used for the animation */ |
| var elapsedTime = parseFloat(ev.elapsedTime.toFixed(ELAPSED_TIME_MAX_DECIMAL_PLACES)); |
| |
| /* $manualTimeStamp is a mocked timeStamp value which is set |
| * within browserTrigger(). This is only here so that tests can |
| * mock animations properly. Real events fallback to event.timeStamp, |
| * or, if they don't, then a timeStamp is automatically created for them. |
| * We're checking to see if the timeStamp surpasses the expected delay, |
| * but we're using elapsedTime instead of the timeStamp on the 2nd |
| * pre-condition since animations sometimes close off early */ |
| if(Math.max(timeStamp - startTime, 0) >= maxDelayTime && elapsedTime >= maxDuration) { |
| activeAnimationComplete(); |
| } |
| } |
| } |
| |
| function prepareStaggerDelay(delayStyle, staggerDelay, index) { |
| var style = ''; |
| forEach(delayStyle.split(','), function(val, i) { |
| style += (i > 0 ? ',' : '') + |
| (index * staggerDelay + parseInt(val, 10)) + 's'; |
| }); |
| return style; |
| } |
| |
| function animateBefore(animationEvent, element, className, calculationDecorator) { |
| if(animateSetup(animationEvent, element, className, calculationDecorator)) { |
| return function(cancelled) { |
| cancelled && animateClose(element, className); |
| }; |
| } |
| } |
| |
| function animateAfter(animationEvent, element, className, afterAnimationComplete) { |
| if(element.data(NG_ANIMATE_CSS_DATA_KEY)) { |
| return animateRun(animationEvent, element, className, afterAnimationComplete); |
| } else { |
| animateClose(element, className); |
| afterAnimationComplete(); |
| } |
| } |
| |
| function animate(animationEvent, element, className, animationComplete) { |
| //If the animateSetup function doesn't bother returning a |
| //cancellation function then it means that there is no animation |
| //to perform at all |
| var preReflowCancellation = animateBefore(animationEvent, element, className); |
| if(!preReflowCancellation) { |
| animationComplete(); |
| return; |
| } |
| |
| //There are two cancellation functions: one is before the first |
| //reflow animation and the second is during the active state |
| //animation. The first function will take care of removing the |
| //data from the element which will not make the 2nd animation |
| //happen in the first place |
| var cancel = preReflowCancellation; |
| afterReflow(element, function() { |
| //once the reflow is complete then we point cancel to |
| //the new cancellation function which will remove all of the |
| //animation properties from the active animation |
| cancel = animateAfter(animationEvent, element, className, animationComplete); |
| }); |
| |
| return function(cancelled) { |
| (cancel || noop)(cancelled); |
| }; |
| } |
| |
| function animateClose(element, className) { |
| element.removeClass(className); |
| var data = element.data(NG_ANIMATE_CSS_DATA_KEY); |
| if(data) { |
| if(data.running) { |
| data.running--; |
| } |
| if(!data.running || data.running === 0) { |
| element.removeData(NG_ANIMATE_CSS_DATA_KEY); |
| } |
| } |
| } |
| |
| return { |
| enter : function(element, animationCompleted) { |
| return animate('enter', element, 'ng-enter', animationCompleted); |
| }, |
| |
| leave : function(element, animationCompleted) { |
| return animate('leave', element, 'ng-leave', animationCompleted); |
| }, |
| |
| move : function(element, animationCompleted) { |
| return animate('move', element, 'ng-move', animationCompleted); |
| }, |
| |
| beforeSetClass : function(element, add, remove, animationCompleted) { |
| var className = suffixClasses(remove, '-remove') + ' ' + |
| suffixClasses(add, '-add'); |
| var cancellationMethod = animateBefore('setClass', element, className); |
| if(cancellationMethod) { |
| afterReflow(element, animationCompleted); |
| return cancellationMethod; |
| } |
| animationCompleted(); |
| }, |
| |
| beforeAddClass : function(element, className, animationCompleted) { |
| var cancellationMethod = animateBefore('addClass', element, suffixClasses(className, '-add')); |
| if(cancellationMethod) { |
| afterReflow(element, animationCompleted); |
| return cancellationMethod; |
| } |
| animationCompleted(); |
| }, |
| |
| beforeRemoveClass : function(element, className, animationCompleted) { |
| var cancellationMethod = animateBefore('removeClass', element, suffixClasses(className, '-remove')); |
| if(cancellationMethod) { |
| afterReflow(element, animationCompleted); |
| return cancellationMethod; |
| } |
| animationCompleted(); |
| }, |
| |
| setClass : function(element, add, remove, animationCompleted) { |
| remove = suffixClasses(remove, '-remove'); |
| add = suffixClasses(add, '-add'); |
| var className = remove + ' ' + add; |
| return animateAfter('setClass', element, className, animationCompleted); |
| }, |
| |
| addClass : function(element, className, animationCompleted) { |
| return animateAfter('addClass', element, suffixClasses(className, '-add'), animationCompleted); |
| }, |
| |
| removeClass : function(element, className, animationCompleted) { |
| return animateAfter('removeClass', element, suffixClasses(className, '-remove'), animationCompleted); |
| } |
| }; |
| |
| function suffixClasses(classes, suffix) { |
| var className = ''; |
| classes = angular.isArray(classes) ? classes : classes.split(/\s+/); |
| forEach(classes, function(klass, i) { |
| if(klass && klass.length > 0) { |
| className += (i > 0 ? ' ' : '') + klass + suffix; |
| } |
| }); |
| return className; |
| } |
| }]); |
| }]); |
| |
| |
| })(window, window.angular); |
