34255 lines · 1.2 MB · JavaScript
RawDownload
       * @description Triggers a removeClass animation surrounding the removal of the provided CSS class(es). Upon       *   execution, the removeClass operation will only be handled after the next digest and it will not trigger an       *   animation if element does not contain the CSS class or if the class is added at a later step.       *   Note that class-based animations are treated differently compared to structural animations       *   (like enter, move and leave) since the CSS classes may be added/removed at different points       *   depending if CSS or JavaScript animations are used.       *       * @param {DOMElement} element the element which the CSS classes will be applied to       * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)       * @param {object=} options an optional collection of options/styles that will be applied to the element.       *   The object can have the following properties:       *       *   - **addClass** - `{string}` - space-separated CSS classes to add to element       *   - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`       *   - **removeClass** - `{string}` - space-separated CSS classes to remove from element       *   - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`       *       * @return {Promise} the animation callback promise       */      removeClass: function(element, className, options) {        options = prepareAnimateOptions(options);        options.removeClass = mergeClasses(options.removeClass, className);        return $$animateQueue.push(element, 'removeClass', options);      },       /**       * @ngdoc method       * @name $animate#setClass       * @kind function       *       * @description Performs both the addition and removal of a CSS classes on an element and (during the process)       *    triggers an animation surrounding the class addition/removal. Much like `$animate.addClass` and       *    `$animate.removeClass`, `setClass` will only evaluate the classes being added/removed once a digest has       *    passed. Note that class-based animations are treated differently compared to structural animations       *    (like enter, move and leave) since the CSS classes may be added/removed at different points       *    depending if CSS or JavaScript animations are used.       *       * @param {DOMElement} element the element which the CSS classes will be applied to       * @param {string} add the CSS class(es) that will be added (multiple classes are separated via spaces)       * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)       * @param {object=} options an optional collection of options/styles that will be applied to the element.       *   The object can have the following properties:       *       *   - **addClass** - `{string}` - space-separated CSS classes to add to element       *   - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`       *   - **removeClass** - `{string}` - space-separated CSS classes to remove from element       *   - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`       *       * @return {Promise} the animation callback promise       */      setClass: function(element, add, remove, options) {        options = prepareAnimateOptions(options);        options.addClass = mergeClasses(options.addClass, add);        options.removeClass = mergeClasses(options.removeClass, remove);        return $$animateQueue.push(element, 'setClass', options);      },       /**       * @ngdoc method       * @name $animate#animate       * @kind function       *       * @description Performs an inline animation on the element which applies the provided to and from CSS styles to the element.       * If any detected CSS transition, keyframe or JavaScript matches the provided className value, then the animation will take       * on the provided styles. For example, if a transition animation is set for the given className, then the provided `from` and       * `to` styles will be applied alongside the given transition. If the CSS style provided in `from` does not have a corresponding       * style in `to`, the style in `from` is applied immediately, and no animation is run.       * If a JavaScript animation is detected then the provided styles will be given in as function parameters into the `animate`       * method (or as part of the `options` parameter):       *       * ```js       * ngModule.animation('.my-inline-animation', function() {       *   return {       *     animate : function(element, from, to, done, options) {       *       //animation       *       done();       *     }       *   }       * });       * ```       *       * @param {DOMElement} element the element which the CSS styles will be applied to       * @param {object} from the from (starting) CSS styles that will be applied to the element and across the animation.       * @param {object} to the to (destination) CSS styles that will be applied to the element and across the animation.       * @param {string=} className an optional CSS class that will be applied to the element for the duration of the animation. If       *    this value is left as empty then a CSS class of `ng-inline-animate` will be applied to the element.       *    (Note that if no animation is detected then this value will not be applied to the element.)       * @param {object=} options an optional collection of options/styles that will be applied to the element.       *   The object can have the following properties:       *       *   - **addClass** - `{string}` - space-separated CSS classes to add to element       *   - **from** - `{Object}` - CSS properties & values at the beginning of animation. Must have matching `to`       *   - **removeClass** - `{string}` - space-separated CSS classes to remove from element       *   - **to** - `{Object}` - CSS properties & values at end of animation. Must have matching `from`       *       * @return {Promise} the animation callback promise       */      animate: function(element, from, to, className, options) {        options = prepareAnimateOptions(options);        options.from = options.from ? extend(options.from, from) : from;        options.to   = options.to   ? extend(options.to, to)     : to;         className = className || 'ng-inline-animate';        options.tempClasses = mergeClasses(options.tempClasses, className);        return $$animateQueue.push(element, 'animate', options);      }    };  }];}]; var $$AnimateAsyncRunFactoryProvider = /** @this */ function() {  this.$get = ['$$rAF', function($$rAF) {    var waitQueue = [];     function waitForTick(fn) {      waitQueue.push(fn);      if (waitQueue.length > 1) return;      $$rAF(function() {        for (var i = 0; i < waitQueue.length; i++) {          waitQueue[i]();        }        waitQueue = [];      });    }     return function() {      var passed = false;      waitForTick(function() {        passed = true;      });      return function(callback) {        if (passed) {          callback();        } else {          waitForTick(callback);        }      };    };  }];}; var $$AnimateRunnerFactoryProvider = /** @this */ function() {  this.$get = ['$q', '$sniffer', '$$animateAsyncRun', '$$isDocumentHidden', '$timeout',       function($q,   $sniffer,   $$animateAsyncRun,   $$isDocumentHidden,   $timeout) {     var INITIAL_STATE = 0;    var DONE_PENDING_STATE = 1;    var DONE_COMPLETE_STATE = 2;     AnimateRunner.chain = function(chain, callback) {      var index = 0;       next();      function next() {        if (index === chain.length) {          callback(true);          return;        }         chain[index](function(response) {          if (response === false) {            callback(false);            return;          }          index++;          next();        });      }    };     AnimateRunner.all = function(runners, callback) {      var count = 0;      var status = true;      forEach(runners, function(runner) {        runner.done(onProgress);      });       function onProgress(response) {        status = status && response;        if (++count === runners.length) {          callback(status);        }      }    };     function AnimateRunner(host) {      this.setHost(host);       var rafTick = $$animateAsyncRun();      var timeoutTick = function(fn) {        $timeout(fn, 0, false);      };       this._doneCallbacks = [];      this._tick = function(fn) {        if ($$isDocumentHidden()) {          timeoutTick(fn);        } else {          rafTick(fn);        }      };      this._state = 0;    }     AnimateRunner.prototype = {      setHost: function(host) {        this.host = host || {};      },       done: function(fn) {        if (this._state === DONE_COMPLETE_STATE) {          fn();        } else {          this._doneCallbacks.push(fn);        }      },       progress: noop,       getPromise: function() {        if (!this.promise) {          var self = this;          this.promise = $q(function(resolve, reject) {            self.done(function(status) {              if (status === false) {                reject();              } else {                resolve();              }            });          });        }        return this.promise;      },       then: function(resolveHandler, rejectHandler) {        return this.getPromise().then(resolveHandler, rejectHandler);      },       'catch': function(handler) {        return this.getPromise()['catch'](handler);      },       'finally': function(handler) {        return this.getPromise()['finally'](handler);      },       pause: function() {        if (this.host.pause) {          this.host.pause();        }      },       resume: function() {        if (this.host.resume) {          this.host.resume();        }      },       end: function() {        if (this.host.end) {          this.host.end();        }        this._resolve(true);      },       cancel: function() {        if (this.host.cancel) {          this.host.cancel();        }        this._resolve(false);      },       complete: function(response) {        var self = this;        if (self._state === INITIAL_STATE) {          self._state = DONE_PENDING_STATE;          self._tick(function() {            self._resolve(response);          });        }      },       _resolve: function(response) {        if (this._state !== DONE_COMPLETE_STATE) {          forEach(this._doneCallbacks, function(fn) {            fn(response);          });          this._doneCallbacks.length = 0;          this._state = DONE_COMPLETE_STATE;        }      }    };     return AnimateRunner;  }];}; /* exported $CoreAnimateCssProvider */ /** * @ngdoc service * @name $animateCss * @kind object * @this * * @description * This is the core version of `$animateCss`. By default, only when the `ngAnimate` is included, * then the `$animateCss` service will actually perform animations. * * Click here {@link ngAnimate.$animateCss to read the documentation for $animateCss}. */var $CoreAnimateCssProvider = function() {  this.$get = ['$$rAF', '$q', '$$AnimateRunner', function($$rAF, $q, $$AnimateRunner) {     return function(element, initialOptions) {      // all of the animation functions should create      // a copy of the options data, however, if a      // parent service has already created a copy then      // we should stick to using that      var options = initialOptions || {};      if (!options.$$prepared) {        options = copy(options);      }       // there is no point in applying the styles since      // there is no animation that goes on at all in      // this version of $animateCss.      if (options.cleanupStyles) {        options.from = options.to = null;      }       if (options.from) {        element.css(options.from);        options.from = null;      }       var closed, runner = new $$AnimateRunner();      return {        start: run,        end: run      };       function run() {        $$rAF(function() {          applyAnimationContents();          if (!closed) {            runner.complete();          }          closed = true;        });        return runner;      }       function applyAnimationContents() {        if (options.addClass) {          element.addClass(options.addClass);          options.addClass = null;        }        if (options.removeClass) {          element.removeClass(options.removeClass);          options.removeClass = null;        }        if (options.to) {          element.css(options.to);          options.to = null;        }      }    };  }];}; /* global stripHash: true */ /** * ! This is a private undocumented service ! * * @name $browser * @requires $log * @description * This object has two goals: * * - hide all the global state in the browser caused by the window object * - abstract away all the browser specific features and inconsistencies * * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser` * service, which can be used for convenient testing of the application without the interaction with * the real browser apis. *//** * @param {object} window The global window object. * @param {object} document jQuery wrapped document. * @param {object} $log window.console or an object with the same interface. * @param {object} $sniffer $sniffer service */function Browser(window, document, $log, $sniffer) {  var self = this,      location = window.location,      history = window.history,      setTimeout = window.setTimeout,      clearTimeout = window.clearTimeout,      pendingDeferIds = {};   self.isMock = false;   var outstandingRequestCount = 0;  var outstandingRequestCallbacks = [];   // TODO(vojta): remove this temporary api  self.$$completeOutstandingRequest = completeOutstandingRequest;  self.$$incOutstandingRequestCount = function() { outstandingRequestCount++; };   /**   * Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`   * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.   */  function completeOutstandingRequest(fn) {    try {      fn.apply(null, sliceArgs(arguments, 1));    } finally {      outstandingRequestCount--;      if (outstandingRequestCount === 0) {        while (outstandingRequestCallbacks.length) {          try {            outstandingRequestCallbacks.pop()();          } catch (e) {            $log.error(e);          }        }      }    }  }   function getHash(url) {    var index = url.indexOf('#');    return index === -1 ? '' : url.substr(index);  }   /**   * @private   * TODO(vojta): prefix this method with $$ ?   * @param {function()} callback Function that will be called when no outstanding request   */  self.notifyWhenNoOutstandingRequests = function(callback) {    if (outstandingRequestCount === 0) {      callback();    } else {      outstandingRequestCallbacks.push(callback);    }  };   //////////////////////////////////////////////////////////////  // URL API  //////////////////////////////////////////////////////////////   var cachedState, lastHistoryState,      lastBrowserUrl = location.href,      baseElement = document.find('base'),      pendingLocation = null,      getCurrentState = !$sniffer.history ? noop : function getCurrentState() {        try {          return history.state;        } catch (e) {          // MSIE can reportedly throw when there is no state (UNCONFIRMED).        }      };   cacheState();   /**   * @name $browser#url   *   * @description   * GETTER:   * Without any argument, this method just returns current value of location.href.   *   * SETTER:   * With at least one argument, this method sets url to new value.   * If html5 history api supported, pushState/replaceState is used, otherwise   * location.href/location.replace is used.   * Returns its own instance to allow chaining   *   * NOTE: this api is intended for use only by the $location service. Please use the   * {@link ng.$location $location service} to change url.   *   * @param {string} url New url (when used as setter)   * @param {boolean=} replace Should new url replace current history record?   * @param {object=} state object to use with pushState/replaceState   */  self.url = function(url, replace, state) {    // In modern browsers `history.state` is `null` by default; treating it separately    // from `undefined` would cause `$browser.url('/foo')` to change `history.state`    // to undefined via `pushState`. Instead, let's change `undefined` to `null` here.    if (isUndefined(state)) {      state = null;    }     // Android Browser BFCache causes location, history reference to become stale.    if (location !== window.location) location = window.location;    if (history !== window.history) history = window.history;

Lines 6001–6500 of 34255. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t