34255 lines · 1.2 MB · JavaScript
RawDownload
   *   * @description   * Call this method to enable/disable various debug runtime information in the compiler such as adding   * binding information and a reference to the current scope on to DOM elements.   * If enabled, the compiler will add the following to DOM elements that have been bound to the scope   * * `ng-binding` CSS class   * * `ng-scope` and `ng-isolated-scope` CSS classes   * * `$binding` data property containing an array of the binding expressions   * * Data properties used by the {@link angular.element#methods `scope()`/`isolateScope()` methods} to return   *   the element's scope.   * * Placeholder comments will contain information about what directive and binding caused the placeholder.   *   E.g. `<!-- ngIf: shouldShow() -->`.   *   * You may want to disable this in production for a significant performance boost. See   * {@link guide/production#disabling-debug-data Disabling Debug Data} for more.   *   * The default value is true.   */  var debugInfoEnabled = true;  this.debugInfoEnabled = function(enabled) {    if (isDefined(enabled)) {      debugInfoEnabled = enabled;      return this;    }    return debugInfoEnabled;  };   /**   * @ngdoc method   * @name  $compileProvider#preAssignBindingsEnabled   *   * @param {boolean=} enabled update the preAssignBindingsEnabled state if provided, otherwise just return the   * current preAssignBindingsEnabled state   * @returns {*} current value if used as getter or itself (chaining) if used as setter   *   * @kind function   *   * @description   * Call this method to enable/disable whether directive controllers are assigned bindings before   * calling the controller's constructor.   * If enabled (true), the compiler assigns the value of each of the bindings to the   * properties of the controller object before the constructor of this object is called.   *   * If disabled (false), the compiler calls the constructor first before assigning bindings.   *   * The default value is false.   *   * @deprecated   * sinceVersion="1.6.0"   * removeVersion="1.7.0"   *   * This method and the option to assign the bindings before calling the controller's constructor   * will be removed in v1.7.0.   */  var preAssignBindingsEnabled = false;  this.preAssignBindingsEnabled = function(enabled) {    if (isDefined(enabled)) {      preAssignBindingsEnabled = enabled;      return this;    }    return preAssignBindingsEnabled;  };   /**   * @ngdoc method   * @name  $compileProvider#strictComponentBindingsEnabled   *   * @param {boolean=} enabled update the strictComponentBindingsEnabled state if provided, otherwise just return the   * current strictComponentBindingsEnabled state   * @returns {*} current value if used as getter or itself (chaining) if used as setter   *   * @kind function   *   * @description   * Call this method to enable/disable strict component bindings check. If enabled, the compiler will enforce that   * for all bindings of a component that are not set as optional with `?`, an attribute needs to be provided   * on the component's HTML tag.   *   * The default value is false.   */  var strictComponentBindingsEnabled = false;  this.strictComponentBindingsEnabled = function(enabled) {    if (isDefined(enabled)) {      strictComponentBindingsEnabled = enabled;      return this;    }    return strictComponentBindingsEnabled;  };   var TTL = 10;  /**   * @ngdoc method   * @name $compileProvider#onChangesTtl   * @description   *   * Sets the number of times `$onChanges` hooks can trigger new changes before giving up and   * assuming that the model is unstable.   *   * The current default is 10 iterations.   *   * In complex applications it's possible that dependencies between `$onChanges` hooks and bindings will result   * in several iterations of calls to these hooks. However if an application needs more than the default 10   * iterations to stabilize then you should investigate what is causing the model to continuously change during   * the `$onChanges` hook execution.   *   * Increasing the TTL could have performance implications, so you should not change it without proper justification.   *   * @param {number} limit The number of `$onChanges` hook iterations.   * @returns {number|object} the current limit (or `this` if called as a setter for chaining)   */  this.onChangesTtl = function(value) {    if (arguments.length) {      TTL = value;      return this;    }    return TTL;  };   var commentDirectivesEnabledConfig = true;  /**   * @ngdoc method   * @name $compileProvider#commentDirectivesEnabled   * @description   *   * It indicates to the compiler   * whether or not directives on comments should be compiled.   * Defaults to `true`.   *   * Calling this function with false disables the compilation of directives   * on comments for the whole application.   * This results in a compilation performance gain,   * as the compiler doesn't have to check comments when looking for directives.   * This should however only be used if you are sure that no comment directives are used in   * the application (including any 3rd party directives).   *   * @param {boolean} enabled `false` if the compiler may ignore directives on comments   * @returns {boolean|object} the current value (or `this` if called as a setter for chaining)   */  this.commentDirectivesEnabled = function(value) {    if (arguments.length) {      commentDirectivesEnabledConfig = value;      return this;    }    return commentDirectivesEnabledConfig;  };    var cssClassDirectivesEnabledConfig = true;  /**   * @ngdoc method   * @name $compileProvider#cssClassDirectivesEnabled   * @description   *   * It indicates to the compiler   * whether or not directives on element classes should be compiled.   * Defaults to `true`.   *   * Calling this function with false disables the compilation of directives   * on element classes for the whole application.   * This results in a compilation performance gain,   * as the compiler doesn't have to check element classes when looking for directives.   * This should however only be used if you are sure that no class directives are used in   * the application (including any 3rd party directives).   *   * @param {boolean} enabled `false` if the compiler may ignore directives on element classes   * @returns {boolean|object} the current value (or `this` if called as a setter for chaining)   */  this.cssClassDirectivesEnabled = function(value) {    if (arguments.length) {      cssClassDirectivesEnabledConfig = value;      return this;    }    return cssClassDirectivesEnabledConfig;  };   this.$get = [            '$injector', '$interpolate', '$exceptionHandler', '$templateRequest', '$parse',            '$controller', '$rootScope', '$sce', '$animate', '$$sanitizeUri',    function($injector,   $interpolate,   $exceptionHandler,   $templateRequest,   $parse,             $controller,   $rootScope,   $sce,   $animate,   $$sanitizeUri) {     var SIMPLE_ATTR_NAME = /^\w/;    var specialAttrHolder = window.document.createElement('div');      var commentDirectivesEnabled = commentDirectivesEnabledConfig;    var cssClassDirectivesEnabled = cssClassDirectivesEnabledConfig;      var onChangesTtl = TTL;    // The onChanges hooks should all be run together in a single digest    // When changes occur, the call to trigger their hooks will be added to this queue    var onChangesQueue;     // This function is called in a $$postDigest to trigger all the onChanges hooks in a single digest    function flushOnChangesQueue() {      try {        if (!(--onChangesTtl)) {          // We have hit the TTL limit so reset everything          onChangesQueue = undefined;          throw $compileMinErr('infchng', '{0} $onChanges() iterations reached. Aborting!\n', TTL);        }        // We must run this hook in an apply since the $$postDigest runs outside apply        $rootScope.$apply(function() {          var errors = [];          for (var i = 0, ii = onChangesQueue.length; i < ii; ++i) {            try {              onChangesQueue[i]();            } catch (e) {              errors.push(e);            }          }          // Reset the queue to trigger a new schedule next time there is a change          onChangesQueue = undefined;          if (errors.length) {            throw errors;          }        });      } finally {        onChangesTtl++;      }    }      function Attributes(element, attributesToCopy) {      if (attributesToCopy) {        var keys = Object.keys(attributesToCopy);        var i, l, key;         for (i = 0, l = keys.length; i < l; i++) {          key = keys[i];          this[key] = attributesToCopy[key];        }      } else {        this.$attr = {};      }       this.$$element = element;    }     Attributes.prototype = {      /**       * @ngdoc method       * @name $compile.directive.Attributes#$normalize       * @kind function       *       * @description       * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or       * `data-`) to its normalized, camelCase form.       *       * Also there is special case for Moz prefix starting with upper case letter.       *       * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}       *       * @param {string} name Name to normalize       */      $normalize: directiveNormalize,        /**       * @ngdoc method       * @name $compile.directive.Attributes#$addClass       * @kind function       *       * @description       * Adds the CSS class value specified by the classVal parameter to the element. If animations       * are enabled then an animation will be triggered for the class addition.       *       * @param {string} classVal The className value that will be added to the element       */      $addClass: function(classVal) {        if (classVal && classVal.length > 0) {          $animate.addClass(this.$$element, classVal);        }      },       /**       * @ngdoc method       * @name $compile.directive.Attributes#$removeClass       * @kind function       *       * @description       * Removes the CSS class value specified by the classVal parameter from the element. If       * animations are enabled then an animation will be triggered for the class removal.       *       * @param {string} classVal The className value that will be removed from the element       */      $removeClass: function(classVal) {        if (classVal && classVal.length > 0) {          $animate.removeClass(this.$$element, classVal);        }      },       /**       * @ngdoc method       * @name $compile.directive.Attributes#$updateClass       * @kind function       *       * @description       * Adds and removes the appropriate CSS class values to the element based on the difference       * between the new and old CSS class values (specified as newClasses and oldClasses).       *       * @param {string} newClasses The current CSS className value       * @param {string} oldClasses The former CSS className value       */      $updateClass: function(newClasses, oldClasses) {        var toAdd = tokenDifference(newClasses, oldClasses);        if (toAdd && toAdd.length) {          $animate.addClass(this.$$element, toAdd);        }         var toRemove = tokenDifference(oldClasses, newClasses);        if (toRemove && toRemove.length) {          $animate.removeClass(this.$$element, toRemove);        }      },       /**       * Set a normalized attribute on the element in a way such that all directives       * can share the attribute. This function properly handles boolean attributes.       * @param {string} key Normalized key. (ie ngAttribute)       * @param {string|boolean} value The value to set. If `null` attribute will be deleted.       * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.       *     Defaults to true.       * @param {string=} attrName Optional none normalized name. Defaults to key.       */      $set: function(key, value, writeAttr, attrName) {        // TODO: decide whether or not to throw an error if "class"        //is set through this function since it may cause $updateClass to        //become unstable.         var node = this.$$element[0],            booleanKey = getBooleanAttrName(node, key),            aliasedKey = getAliasedAttrName(key),            observer = key,            nodeName;         if (booleanKey) {          this.$$element.prop(key, value);          attrName = booleanKey;        } else if (aliasedKey) {          this[aliasedKey] = value;          observer = aliasedKey;        }         this[key] = value;         // translate normalized key to actual key        if (attrName) {          this.$attr[key] = attrName;        } else {          attrName = this.$attr[key];          if (!attrName) {            this.$attr[key] = attrName = snake_case(key, '-');          }        }         nodeName = nodeName_(this.$$element);         if ((nodeName === 'a' && (key === 'href' || key === 'xlinkHref')) ||            (nodeName === 'img' && key === 'src')) {          // sanitize a[href] and img[src] values          this[key] = value = $$sanitizeUri(value, key === 'src');        } else if (nodeName === 'img' && key === 'srcset' && isDefined(value)) {          // sanitize img[srcset] values          var result = '';           // first check if there are spaces because it's not the same pattern          var trimmedSrcset = trim(value);          //                (   999x   ,|   999w   ,|   ,|,   )          var srcPattern = /(\s+\d+x\s*,|\s+\d+w\s*,|\s+,|,\s+)/;          var pattern = /\s/.test(trimmedSrcset) ? srcPattern : /(,)/;           // split srcset into tuple of uri and descriptor except for the last item          var rawUris = trimmedSrcset.split(pattern);           // for each tuples          var nbrUrisWith2parts = Math.floor(rawUris.length / 2);          for (var i = 0; i < nbrUrisWith2parts; i++) {            var innerIdx = i * 2;            // sanitize the uri            result += $$sanitizeUri(trim(rawUris[innerIdx]), true);            // add the descriptor            result += (' ' + trim(rawUris[innerIdx + 1]));          }           // split the last item into uri and descriptor          var lastTuple = trim(rawUris[i * 2]).split(/\s/);           // sanitize the last uri          result += $$sanitizeUri(trim(lastTuple[0]), true);           // and add the last descriptor if any          if (lastTuple.length === 2) {            result += (' ' + trim(lastTuple[1]));          }          this[key] = value = result;        }         if (writeAttr !== false) {          if (value === null || isUndefined(value)) {            this.$$element.removeAttr(attrName);          } else {            if (SIMPLE_ATTR_NAME.test(attrName)) {              this.$$element.attr(attrName, value);            } else {              setSpecialAttr(this.$$element[0], attrName, value);            }          }        }         // fire observers        var $$observers = this.$$observers;        if ($$observers) {          forEach($$observers[observer], function(fn) {            try {              fn(value);            } catch (e) {              $exceptionHandler(e);            }          });        }      },        /**       * @ngdoc method       * @name $compile.directive.Attributes#$observe       * @kind function       *       * @description       * Observes an interpolated attribute.       *       * The observer function will be invoked once during the next `$digest` following       * compilation. The observer is then invoked whenever the interpolated value       * changes.       *       * @param {string} key Normalized key. (ie ngAttribute) .       * @param {function(interpolatedValue)} fn Function that will be called whenever                the interpolated value of the attribute changes.       *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation       *        guide} for more info.       * @returns {function()} Returns a deregistration function for this observer.       */      $observe: function(key, fn) {        var attrs = this,            $$observers = (attrs.$$observers || (attrs.$$observers = createMap())),            listeners = ($$observers[key] || ($$observers[key] = []));         listeners.push(fn);        $rootScope.$evalAsync(function() {          if (!listeners.$$inter && attrs.hasOwnProperty(key) && !isUndefined(attrs[key])) {            // no one registered attribute interpolation function, so lets call it manually            fn(attrs[key]);          }        });         return function() {          arrayRemove(listeners, fn);        };      }    };     function setSpecialAttr(element, attrName, value) {      // Attributes names that do not start with letters (such as `(click)`) cannot be set using `setAttribute`      // so we have to jump through some hoops to get such an attribute      // https://github.com/angular/angular.js/pull/13318      specialAttrHolder.innerHTML = '<span ' + attrName + '>';      var attributes = specialAttrHolder.firstChild.attributes;      var attribute = attributes[0];      // We have to remove the attribute from its container element before we can add it to the destination element      attributes.removeNamedItem(attribute.name);      attribute.value = value;      element.attributes.setNamedItem(attribute);    }     function safeAddClass($element, className) {      try {        $element.addClass(className);      } catch (e) {        // ignore, since it means that we are trying to set class on        // SVG element, where class name is read-only.      }    }      var startSymbol = $interpolate.startSymbol(),        endSymbol = $interpolate.endSymbol(),        denormalizeTemplate = (startSymbol === '{{' && endSymbol  === '}}')            ? identity            : function denormalizeTemplate(template) {              return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);        },        NG_ATTR_BINDING = /^ngAttr[A-Z]/;    var MULTI_ELEMENT_DIR_RE = /^(.+)Start$/;     compile.$$addBindingInfo = debugInfoEnabled ? function $$addBindingInfo($element, binding) {      var bindings = $element.data('$binding') || [];       if (isArray(binding)) {

Lines 8501–9000 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