diff options
Diffstat (limited to 'xstatic/pkg/angular/data/angular-messages.js')
| -rw-r--r-- | xstatic/pkg/angular/data/angular-messages.js | 649 |
1 files changed, 477 insertions, 172 deletions
diff --git a/xstatic/pkg/angular/data/angular-messages.js b/xstatic/pkg/angular/data/angular-messages.js index 6d32f5c..ad55265 100644 --- a/xstatic/pkg/angular/data/angular-messages.js +++ b/xstatic/pkg/angular/data/angular-messages.js @@ -1,10 +1,18 @@ /** - * @license AngularJS v1.3.18 - * (c) 2010-2014 Google, Inc. http://angularjs.org + * @license AngularJS v1.4.10 + * (c) 2010-2015 Google, Inc. http://angularjs.org * License: MIT */ (function(window, angular, undefined) {'use strict'; +/* jshint ignore:start */ +// this code is in the core, but not in angular-messages.js +var isArray = angular.isArray; +var forEach = angular.forEach; +var isString = angular.isString; +var jqLite = angular.element; +/* jshint ignore:end */ + /** * @ngdoc module * @name ngMessages @@ -17,47 +25,77 @@ * `ngMessage` directives are designed to handle the complexity, inheritance and priority * sequencing based on the order of how the messages are defined in the template. * - * Currently, the ngMessages module only contains the code for the `ngMessages` - * and `ngMessage` directives. + * Currently, the ngMessages module only contains the code for the `ngMessages`, `ngMessagesInclude` + * `ngMessage` and `ngMessageExp` directives. * * # Usage - * The `ngMessages` directive listens on a key/value collection which is set on the ngMessages attribute. - * Since the {@link ngModel ngModel} directive exposes an `$error` object, this error object can be - * used with `ngMessages` to display control error messages in an easier way than with just regular angular - * template directives. + * The `ngMessages` directive allows keys in a key/value collection to be associated with a child element + * (or 'message') that will show or hide based on the truthiness of that key's value in the collection. A common use + * case for `ngMessages` is to display error messages for inputs using the `$error` object exposed by the + * {@link ngModel ngModel} directive. + * + * The child elements of the `ngMessages` directive are matched to the collection keys by a `ngMessage` or + * `ngMessageExp` directive. The value of these attributes must match a key in the collection that is provided by + * the `ngMessages` directive. + * + * Consider the following example, which illustrates a typical use case of `ngMessages`. Within the form `myForm` we + * have a text input named `myField` which is bound to the scope variable `field` using the {@link ngModel ngModel} + * directive. + * + * The `myField` field is a required input of type `email` with a maximum length of 15 characters. * * ```html * <form name="myForm"> - * <input type="text" ng-model="field" name="myField" required minlength="5" /> - * <div ng-messages="myForm.myField.$error"> - * <div ng-message="required">You did not enter a field</div> - * <div ng-message="minlength">The value entered is too short</div> + * <label> + * Enter text: + * <input type="email" ng-model="field" name="myField" required maxlength="15" /> + * </label> + * <div ng-messages="myForm.myField.$error" role="alert"> + * <div ng-message="required">Please enter a value for this field.</div> + * <div ng-message="email">This field must be a valid email address.</div> + * <div ng-message="maxlength">This field can be at most 15 characters long.</div> * </div> * </form> * ``` * - * Now whatever key/value entries are present within the provided object (in this case `$error`) then - * the ngMessages directive will render the inner first ngMessage directive (depending if the key values - * match the attribute value present on each ngMessage directive). In other words, if your errors - * object contains the following data: + * In order to show error messages corresponding to `myField` we first create an element with an `ngMessages` attribute + * set to the `$error` object owned by the `myField` input in our `myForm` form. + * + * Within this element we then create separate elements for each of the possible errors that `myField` could have. + * The `ngMessage` attribute is used to declare which element(s) will appear for which error - for example, + * setting `ng-message="required"` specifies that this particular element should be displayed when there + * is no value present for the required field `myField` (because the key `required` will be `true` in the object + * `myForm.myField.$error`). + * + * ### Message order + * + * By default, `ngMessages` will only display one message for a particular key/value collection at any time. If more + * than one message (or error) key is currently true, then which message is shown is determined by the order of messages + * in the HTML template code (messages declared first are prioritised). This mechanism means the developer does not have + * to prioritise messages using custom JavaScript code. + * + * Given the following error object for our example (which informs us that the field `myField` currently has both the + * `required` and `email` errors): * * ```javascript * <!-- keep in mind that ngModel automatically sets these error flags --> - * myField.$error = { minlength : true, required : false }; + * myField.$error = { required : true, email: true, maxlength: false }; * ``` + * The `required` message will be displayed to the user since it appears before the `email` message in the DOM. + * Once the user types a single character, the `required` message will disappear (since the field now has a value) + * but the `email` message will be visible because it is still applicable. * - * Then the `required` message will be displayed first. When required is false then the `minlength` message - * will be displayed right after (since these messages are ordered this way in the template HTML code). - * The prioritization of each message is determined by what order they're present in the DOM. - * Therefore, instead of having custom JavaScript code determine the priority of what errors are - * present before others, the presentation of the errors are handled within the template. + * ### Displaying multiple messages at the same time * - * By default, ngMessages will only display one error at a time. However, if you wish to display all - * messages then the `ng-messages-multiple` attribute flag can be used on the element containing the - * ngMessages directive to make this happen. + * While `ngMessages` will by default only display one error element at a time, the `ng-messages-multiple` attribute can + * be applied to the `ngMessages` container element to cause it to display all applicable error messages at once: * * ```html + * <!-- attribute-style usage --> * <div ng-messages="myForm.myField.$error" ng-messages-multiple>...</div> + * + * <!-- element-style usage --> + * <ng-messages for="myForm.myField.$error" multiple>...</ng-messages> * ``` * * ## Reusing and Overriding Messages @@ -70,12 +108,15 @@ * <div ng-message="required">This field is required</div> * <div ng-message="minlength">This field is too short</div> * </script> - * <div ng-messages="myForm.myField.$error" ng-messages-include="error-messages"></div> + * + * <div ng-messages="myForm.myField.$error" role="alert"> + * <div ng-messages-include="error-messages"></div> + * </div> * ``` * * However, including generic messages may not be useful enough to match all input fields, therefore, * `ngMessages` provides the ability to override messages defined in the remote template by redefining - * then within the directive container. + * them within the directive container. * * ```html * <!-- a generic template of error messages known as "my-custom-messages" --> @@ -85,19 +126,26 @@ * </script> * * <form name="myForm"> - * <input type="email" - * id="email" - * name="myEmail" - * ng-model="email" - * minlength="5" - * required /> - * - * <div ng-messages="myForm.myEmail.$error" ng-messages-include="my-custom-messages"> + * <label> + * Email address + * <input type="email" + * id="email" + * name="myEmail" + * ng-model="email" + * minlength="5" + * required /> + * </label> + * <!-- any ng-message elements that appear BEFORE the ng-messages-include will + * override the messages present in the ng-messages-include template --> + * <div ng-messages="myForm.myEmail.$error" role="alert"> * <!-- this required message has overridden the template message --> * <div ng-message="required">You did not enter your email address</div> * * <!-- this is a brand new message and will appear last in the prioritization --> * <div ng-message="email">Your email address is invalid</div> + * + * <!-- and here are the generic error messages --> + * <div ng-messages-include="my-custom-messages"></div> * </div> * </form> * ``` @@ -107,20 +155,80 @@ * email addresses, date fields, autocomplete inputs, etc...), specialized error messages can be applied * while more generic messages can be used to handle other, more general input errors. * + * ## Dynamic Messaging + * ngMessages also supports using expressions to dynamically change key values. Using arrays and + * repeaters to list messages is also supported. This means that the code below will be able to + * fully adapt itself and display the appropriate message when any of the expression data changes: + * + * ```html + * <form name="myForm"> + * <label> + * Email address + * <input type="email" + * name="myEmail" + * ng-model="email" + * minlength="5" + * required /> + * </label> + * <div ng-messages="myForm.myEmail.$error" role="alert"> + * <div ng-message="required">You did not enter your email address</div> + * <div ng-repeat="errorMessage in errorMessages"> + * <!-- use ng-message-exp for a message whose key is given by an expression --> + * <div ng-message-exp="errorMessage.type">{{ errorMessage.text }}</div> + * </div> + * </div> + * </form> + * ``` + * + * The `errorMessage.type` expression can be a string value or it can be an array so + * that multiple errors can be associated with a single error message: + * + * ```html + * <label> + * Email address + * <input type="email" + * ng-model="data.email" + * name="myEmail" + * ng-minlength="5" + * ng-maxlength="100" + * required /> + * </label> + * <div ng-messages="myForm.myEmail.$error" role="alert"> + * <div ng-message-exp="'required'">You did not enter your email address</div> + * <div ng-message-exp="['minlength', 'maxlength']"> + * Your email must be between 5 and 100 characters long + * </div> + * </div> + * ``` + * + * Feel free to use other structural directives such as ng-if and ng-switch to further control + * what messages are active and when. Be careful, if you place ng-message on the same element + * as these structural directives, Angular may not be able to determine if a message is active + * or not. Therefore it is best to place the ng-message on a child element of the structural + * directive. + * + * ```html + * <div ng-messages="myForm.myEmail.$error" role="alert"> + * <div ng-if="showRequiredError"> + * <div ng-message="required">Please enter something</div> + * </div> + * </div> + * ``` + * * ## Animations - * If the `ngAnimate` module is active within the application then both the `ngMessages` and - * `ngMessage` directives will trigger animations whenever any messages are added and removed - * from the DOM by the `ngMessages` directive. + * If the `ngAnimate` module is active within the application then the `ngMessages`, `ngMessage` and + * `ngMessageExp` directives will trigger animations whenever any messages are added and removed from + * the DOM by the `ngMessages` directive. * * Whenever the `ngMessages` directive contains one or more visible messages then the `.ng-active` CSS * class will be added to the element. The `.ng-inactive` CSS class will be applied when there are no - * animations present. Therefore, CSS transitions and keyframes as well as JavaScript animations can + * messages present. Therefore, CSS transitions and keyframes as well as JavaScript animations can * hook into the animations whenever these classes are added/removed. * * Let's say that our HTML code for our messages container looks like so: * * ```html - * <div ng-messages="myMessages" class="my-messages"> + * <div ng-messages="myMessages" class="my-messages" role="alert"> * <div ng-message="alert" class="some-message">...</div> * <div ng-message="fail" class="some-message">...</div> * </div> @@ -169,14 +277,14 @@ angular.module('ngMessages', []) * * @description * `ngMessages` is a directive that is designed to show and hide messages based on the state - * of a key/value object that it listens on. The directive itself compliments error message + * of a key/value object that it listens on. The directive itself complements error message * reporting with the `ngModel` $error object (which stores a key/value state of validation errors). * * `ngMessages` manages the state of internal messages within its container element. The internal * messages use the `ngMessage` directive and will be inserted/removed from the page depending * on if they're present within the key/value object. By default, only one message will be displayed * at a time and this depends on the prioritization of the messages within the template. (This can - * be changed by using the ng-messages-multiple on the directive container.) + * be changed by using the `ng-messages-multiple` or `multiple` attribute on the directive container.) * * A remote template can also be used to promote message reusability and messages can also be * overridden. @@ -186,24 +294,23 @@ angular.module('ngMessages', []) * @usage * ```html * <!-- using attribute directives --> - * <ANY ng-messages="expression"> - * <ANY ng-message="keyValue1">...</ANY> - * <ANY ng-message="keyValue2">...</ANY> - * <ANY ng-message="keyValue3">...</ANY> + * <ANY ng-messages="expression" role="alert"> + * <ANY ng-message="stringValue">...</ANY> + * <ANY ng-message="stringValue1, stringValue2, ...">...</ANY> + * <ANY ng-message-exp="expressionValue">...</ANY> * </ANY> * * <!-- or by using element directives --> - * <ng-messages for="expression"> - * <ng-message when="keyValue1">...</ng-message> - * <ng-message when="keyValue2">...</ng-message> - * <ng-message when="keyValue3">...</ng-message> + * <ng-messages for="expression" role="alert"> + * <ng-message when="stringValue">...</ng-message> + * <ng-message when="stringValue1, stringValue2, ...">...</ng-message> + * <ng-message when-exp="expressionValue">...</ng-message> * </ng-messages> * ``` * * @param {string} ngMessages an angular expression evaluating to a key/value object * (this is typically the $error object on an ngModel instance). * @param {string=} ngMessagesMultiple|multiple when set, all messages will be displayed with true - * @param {string=} ngMessagesInclude|include when set, the specified template will be included into the ng-messages container * * @example * <example name="ngMessages-directive" module="ngMessagesExample" @@ -211,17 +318,18 @@ angular.module('ngMessages', []) * animations="true" fixBase="true"> * <file name="index.html"> * <form name="myForm"> - * <label>Enter your name:</label> - * <input type="text" - * name="myName" - * ng-model="name" - * ng-minlength="5" - * ng-maxlength="20" - * required /> - * + * <label> + * Enter your name: + * <input type="text" + * name="myName" + * ng-model="name" + * ng-minlength="5" + * ng-maxlength="20" + * required /> + * </label> * <pre>myForm.myName.$error = {{ myForm.myName.$error | json }}</pre> * - * <div ng-messages="myForm.myName.$error" style="color:maroon"> + * <div ng-messages="myForm.myName.$error" style="color:maroon" role="alert"> * <div ng-message="required">You did not enter a field</div> * <div ng-message="minlength">Your field is too short</div> * <div ng-message="maxlength">Your field is too long</div> @@ -233,91 +341,223 @@ angular.module('ngMessages', []) * </file> * </example> */ - .directive('ngMessages', ['$compile', '$animate', '$templateRequest', - function($compile, $animate, $templateRequest) { - var ACTIVE_CLASS = 'ng-active'; - var INACTIVE_CLASS = 'ng-inactive'; + .directive('ngMessages', ['$animate', function($animate) { + var ACTIVE_CLASS = 'ng-active'; + var INACTIVE_CLASS = 'ng-inactive'; - return { - restrict: 'AE', - controller: function() { - this.$renderNgMessageClasses = angular.noop; - - var messages = []; - this.registerMessage = function(index, message) { - for (var i = 0; i < messages.length; i++) { - if (messages[i].type == message.type) { - if (index != i) { - var temp = messages[index]; - messages[index] = messages[i]; - if (index < messages.length) { - messages[i] = temp; - } else { - messages.splice(0, i); //remove the old one (and shift left) - } - } - return; - } - } - messages.splice(index, 0, message); //add the new one (and shift right) - }; + return { + require: 'ngMessages', + restrict: 'AE', + controller: ['$element', '$scope', '$attrs', function($element, $scope, $attrs) { + var ctrl = this; + var latestKey = 0; + var nextAttachId = 0; - this.renderMessages = function(values, multiple) { - values = values || {}; + this.getAttachId = function getAttachId() { return nextAttachId++; }; - var found; - angular.forEach(messages, function(message) { - if ((!found || multiple) && truthyVal(values[message.type])) { - message.attach(); - found = true; - } else { - message.detach(); - } - }); + var messages = this.messages = {}; + var renderLater, cachedCollection; - this.renderElementClasses(found); + this.render = function(collection) { + collection = collection || {}; - function truthyVal(value) { - return value !== null && value !== false && value; - } - }; - }, - require: 'ngMessages', - link: function($scope, element, $attrs, ctrl) { - ctrl.renderElementClasses = function(bool) { - bool ? $animate.setClass(element, ACTIVE_CLASS, INACTIVE_CLASS) - : $animate.setClass(element, INACTIVE_CLASS, ACTIVE_CLASS); - }; + renderLater = false; + cachedCollection = collection; - //JavaScript treats empty strings as false, but ng-message-multiple by itself is an empty string - var multiple = angular.isString($attrs.ngMessagesMultiple) || - angular.isString($attrs.multiple); + // this is true if the attribute is empty or if the attribute value is truthy + var multiple = isAttrTruthy($scope, $attrs.ngMessagesMultiple) || + isAttrTruthy($scope, $attrs.multiple); - var cachedValues, watchAttr = $attrs.ngMessages || $attrs['for']; //for is a reserved keyword - $scope.$watchCollection(watchAttr, function(values) { - cachedValues = values; - ctrl.renderMessages(values, multiple); - }); + var unmatchedMessages = []; + var matchedKeys = {}; + var messageItem = ctrl.head; + var messageFound = false; + var totalMessages = 0; - var tpl = $attrs.ngMessagesInclude || $attrs.include; - if (tpl) { - $templateRequest(tpl) - .then(function processTemplate(html) { - var after, container = angular.element('<div/>').html(html); - angular.forEach(container.children(), function(elm) { - elm = angular.element(elm); - after ? after.after(elm) - : element.prepend(elm); //start of the container - after = elm; - $compile(elm)($scope); - }); - ctrl.renderMessages(cachedValues, multiple); - }); - } - } - }; - }]) + // we use != instead of !== to allow for both undefined and null values + while (messageItem != null) { + totalMessages++; + var messageCtrl = messageItem.message; + + var messageUsed = false; + if (!messageFound) { + forEach(collection, function(value, key) { + if (!messageUsed && truthy(value) && messageCtrl.test(key)) { + // this is to prevent the same error name from showing up twice + if (matchedKeys[key]) return; + matchedKeys[key] = true; + + messageUsed = true; + messageCtrl.attach(); + } + }); + } + + if (messageUsed) { + // unless we want to display multiple messages then we should + // set a flag here to avoid displaying the next message in the list + messageFound = !multiple; + } else { + unmatchedMessages.push(messageCtrl); + } + + messageItem = messageItem.next; + } + + forEach(unmatchedMessages, function(messageCtrl) { + messageCtrl.detach(); + }); + + unmatchedMessages.length !== totalMessages + ? $animate.setClass($element, ACTIVE_CLASS, INACTIVE_CLASS) + : $animate.setClass($element, INACTIVE_CLASS, ACTIVE_CLASS); + }; + + $scope.$watchCollection($attrs.ngMessages || $attrs['for'], ctrl.render); + + this.reRender = function() { + if (!renderLater) { + renderLater = true; + $scope.$evalAsync(function() { + if (renderLater) { + cachedCollection && ctrl.render(cachedCollection); + } + }); + } + }; + + this.register = function(comment, messageCtrl) { + var nextKey = latestKey.toString(); + messages[nextKey] = { + message: messageCtrl + }; + insertMessageNode($element[0], comment, nextKey); + comment.$$ngMessageNode = nextKey; + latestKey++; + + ctrl.reRender(); + }; + + this.deregister = function(comment) { + var key = comment.$$ngMessageNode; + delete comment.$$ngMessageNode; + removeMessageNode($element[0], comment, key); + delete messages[key]; + ctrl.reRender(); + }; + + function findPreviousMessage(parent, comment) { + var prevNode = comment; + var parentLookup = []; + while (prevNode && prevNode !== parent) { + var prevKey = prevNode.$$ngMessageNode; + if (prevKey && prevKey.length) { + return messages[prevKey]; + } + + // dive deeper into the DOM and examine its children for any ngMessage + // comments that may be in an element that appears deeper in the list + if (prevNode.childNodes.length && parentLookup.indexOf(prevNode) == -1) { + parentLookup.push(prevNode); + prevNode = prevNode.childNodes[prevNode.childNodes.length - 1]; + } else { + prevNode = prevNode.previousSibling || prevNode.parentNode; + } + } + } + + function insertMessageNode(parent, comment, key) { + var messageNode = messages[key]; + if (!ctrl.head) { + ctrl.head = messageNode; + } else { + var match = findPreviousMessage(parent, comment); + if (match) { + messageNode.next = match.next; + match.next = messageNode; + } else { + messageNode.next = ctrl.head; + ctrl.head = messageNode; + } + } + } + function removeMessageNode(parent, comment, key) { + var messageNode = messages[key]; + + var match = findPreviousMessage(parent, comment); + if (match) { + match.next = messageNode.next; + } else { + ctrl.head = messageNode.next; + } + } + }] + }; + + function isAttrTruthy(scope, attr) { + return (isString(attr) && attr.length === 0) || //empty attribute + truthy(scope.$eval(attr)); + } + + function truthy(val) { + return isString(val) ? val.length : !!val; + } + }]) + + /** + * @ngdoc directive + * @name ngMessagesInclude + * @restrict AE + * @scope + * + * @description + * `ngMessagesInclude` is a directive with the purpose to import existing ngMessage template + * code from a remote template and place the downloaded template code into the exact spot + * that the ngMessagesInclude directive is placed within the ngMessages container. This allows + * for a series of pre-defined messages to be reused and also allows for the developer to + * determine what messages are overridden due to the placement of the ngMessagesInclude directive. + * + * @usage + * ```html + * <!-- using attribute directives --> + * <ANY ng-messages="expression" role="alert"> + * <ANY ng-messages-include="remoteTplString">...</ANY> + * </ANY> + * + * <!-- or by using element directives --> + * <ng-messages for="expression" role="alert"> + * <ng-messages-include src="expressionValue1">...</ng-messages-include> + * </ng-messages> + * ``` + * + * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`. + * + * @param {string} ngMessagesInclude|src a string value corresponding to the remote template. + */ + .directive('ngMessagesInclude', + ['$templateRequest', '$document', '$compile', function($templateRequest, $document, $compile) { + + return { + restrict: 'AE', + require: '^^ngMessages', // we only require this for validation sake + link: function($scope, element, attrs) { + var src = attrs.ngMessagesInclude || attrs.src; + $templateRequest(src).then(function(html) { + $compile(html)($scope, function(contents) { + element.after(contents); + + // the anchor is placed for debugging purposes + var anchor = jqLite($document[0].createComment(' ngMessagesInclude: ' + src + ' ')); + element.after(anchor); + + // we don't want to pollute the DOM anymore by keeping an empty directive element + element.remove(); + }); + }); + } + }; + }]) /** * @ngdoc directive @@ -337,65 +577,130 @@ angular.module('ngMessages', []) * @usage * ```html * <!-- using attribute directives --> + * <ANY ng-messages="expression" role="alert"> + * <ANY ng-message="stringValue">...</ANY> + * <ANY ng-message="stringValue1, stringValue2, ...">...</ANY> + * </ANY> + * + * <!-- or by using element directives --> + * <ng-messages for="expression" role="alert"> + * <ng-message when="stringValue">...</ng-message> + * <ng-message when="stringValue1, stringValue2, ...">...</ng-message> + * </ng-messages> + * ``` + * + * @param {expression} ngMessage|when a string value corresponding to the message key. + */ + .directive('ngMessage', ngMessageDirectiveFactory('AE')) + + + /** + * @ngdoc directive + * @name ngMessageExp + * @restrict AE + * @scope + * + * @description + * `ngMessageExp` is a directive with the purpose to show and hide a particular message. + * For `ngMessageExp` to operate, a parent `ngMessages` directive on a parent DOM element + * must be situated since it determines which messages are visible based on the state + * of the provided key/value map that `ngMessages` listens on. + * + * @usage + * ```html + * <!-- using attribute directives --> * <ANY ng-messages="expression"> - * <ANY ng-message="keyValue1">...</ANY> - * <ANY ng-message="keyValue2">...</ANY> - * <ANY ng-message="keyValue3">...</ANY> + * <ANY ng-message-exp="expressionValue">...</ANY> * </ANY> * * <!-- or by using element directives --> * <ng-messages for="expression"> - * <ng-message when="keyValue1">...</ng-message> - * <ng-message when="keyValue2">...</ng-message> - * <ng-message when="keyValue3">...</ng-message> + * <ng-message when-exp="expressionValue">...</ng-message> * </ng-messages> * ``` * - * @param {string} ngMessage a string value corresponding to the message key. + * {@link module:ngMessages Click here} to learn more about `ngMessages` and `ngMessage`. + * + * @param {expression} ngMessageExp|whenExp an expression value corresponding to the message key. */ - .directive('ngMessage', ['$animate', function($animate) { - var COMMENT_NODE = 8; + .directive('ngMessageExp', ngMessageDirectiveFactory('A')); + +function ngMessageDirectiveFactory(restrict) { + return ['$animate', function($animate) { return { - require: '^ngMessages', + restrict: 'AE', transclude: 'element', terminal: true, - restrict: 'AE', - link: function($scope, $element, $attrs, ngMessages, $transclude) { - var index, element; - - var commentNode = $element[0]; - var parentNode = commentNode.parentNode; - for (var i = 0, j = 0; i < parentNode.childNodes.length; i++) { - var node = parentNode.childNodes[i]; - if (node.nodeType == COMMENT_NODE && node.nodeValue.indexOf('ngMessage') >= 0) { - if (node === commentNode) { - index = j; - break; - } - j++; - } + require: '^^ngMessages', + link: function(scope, element, attrs, ngMessagesCtrl, $transclude) { + var commentNode = element[0]; + + var records; + var staticExp = attrs.ngMessage || attrs.when; + var dynamicExp = attrs.ngMessageExp || attrs.whenExp; + var assignRecords = function(items) { + records = items + ? (isArray(items) + ? items + : items.split(/[\s,]+/)) + : null; + ngMessagesCtrl.reRender(); + }; + + if (dynamicExp) { + assignRecords(scope.$eval(dynamicExp)); + scope.$watchCollection(dynamicExp, assignRecords); + } else { + assignRecords(staticExp); } - ngMessages.registerMessage(index, { - type: $attrs.ngMessage || $attrs.when, + var currentElement, messageCtrl; + ngMessagesCtrl.register(commentNode, messageCtrl = { + test: function(name) { + return contains(records, name); + }, attach: function() { - if (!element) { - $transclude($scope, function(clone) { - $animate.enter(clone, null, $element); - element = clone; + if (!currentElement) { + $transclude(scope, function(elm) { + $animate.enter(elm, null, element); + currentElement = elm; + + // Each time we attach this node to a message we get a new id that we can match + // when we are destroying the node later. + var $$attachId = currentElement.$$attachId = ngMessagesCtrl.getAttachId(); + + // in the event that the parent element is destroyed + // by any other structural directive then it's time + // to deregister the message from the controller + currentElement.on('$destroy', function() { + if (currentElement && currentElement.$$attachId === $$attachId) { + ngMessagesCtrl.deregister(commentNode); + messageCtrl.detach(); + } + }); }); } }, - detach: function(now) { - if (element) { - $animate.leave(element); - element = null; + detach: function() { + if (currentElement) { + var elm = currentElement; + currentElement = null; + $animate.leave(elm); } } }); } }; - }]); + }]; + + function contains(collection, key) { + if (collection) { + return isArray(collection) + ? collection.indexOf(key) >= 0 + : collection.hasOwnProperty(key); + } + } +} })(window, window.angular); |