| /** |
| * @license AngularJS v1.4.7 |
| * (c) 2010-2015 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| (function(window, document, undefined) {'use strict'; |
| |
| /** |
| * @description |
| * |
| * This object provides a utility for producing rich Error messages within |
| * Angular. It can be called as follows: |
| * |
| * var exampleMinErr = minErr('example'); |
| * throw exampleMinErr('one', 'This {0} is {1}', foo, bar); |
| * |
| * The above creates an instance of minErr in the example namespace. The |
| * resulting error will have a namespaced error code of example.one. The |
| * resulting error will replace {0} with the value of foo, and {1} with the |
| * value of bar. The object is not restricted in the number of arguments it can |
| * take. |
| * |
| * If fewer arguments are specified than necessary for interpolation, the extra |
| * interpolation markers will be preserved in the final string. |
| * |
| * Since data will be parsed statically during a build step, some restrictions |
| * are applied with respect to how minErr instances are created and called. |
| * Instances should have names of the form namespaceMinErr for a minErr created |
| * using minErr('namespace') . Error codes, namespaces and template strings |
| * should all be static strings, not variables or general expressions. |
| * |
| * @param {string} module The namespace to use for the new minErr instance. |
| * @param {function} ErrorConstructor Custom error constructor to be instantiated when returning |
| * error from returned function, for cases when a particular type of error is useful. |
| * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance |
| */ |
| |
| function minErr(module, ErrorConstructor) { |
| ErrorConstructor = ErrorConstructor || Error; |
| return function() { |
| var SKIP_INDEXES = 2; |
| |
| var templateArgs = arguments, |
| code = templateArgs[0], |
| message = '[' + (module ? module + ':' : '') + code + '] ', |
| template = templateArgs[1], |
| paramPrefix, i; |
| |
| message += template.replace(/\{\d+\}/g, function(match) { |
| var index = +match.slice(1, -1), |
| shiftedIndex = index + SKIP_INDEXES; |
| |
| if (shiftedIndex < templateArgs.length) { |
| return toDebugString(templateArgs[shiftedIndex]); |
| } |
| |
| return match; |
| }); |
| |
| message += '\nhttp://errors.angularjs.org/1.4.7/' + |
| (module ? module + '/' : '') + code; |
| |
| for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') { |
| message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' + |
| encodeURIComponent(toDebugString(templateArgs[i])); |
| } |
| |
| return new ErrorConstructor(message); |
| }; |
| } |
| |
| /* We need to tell jshint what variables are being exported */ |
| /* global angular: true, |
| msie: true, |
| jqLite: true, |
| jQuery: true, |
| slice: true, |
| splice: true, |
| push: true, |
| toString: true, |
| ngMinErr: true, |
| angularModule: true, |
| uid: true, |
| REGEX_STRING_REGEXP: true, |
| VALIDITY_STATE_PROPERTY: true, |
| |
| lowercase: true, |
| uppercase: true, |
| manualLowercase: true, |
| manualUppercase: true, |
| nodeName_: true, |
| isArrayLike: true, |
| forEach: true, |
| forEachSorted: true, |
| reverseParams: true, |
| nextUid: true, |
| setHashKey: true, |
| extend: true, |
| toInt: true, |
| inherit: true, |
| merge: true, |
| noop: true, |
| identity: true, |
| valueFn: true, |
| isUndefined: true, |
| isDefined: true, |
| isObject: true, |
| isBlankObject: true, |
| isString: true, |
| isNumber: true, |
| isDate: true, |
| isArray: true, |
| isFunction: true, |
| isRegExp: true, |
| isWindow: true, |
| isScope: true, |
| isFile: true, |
| isFormData: true, |
| isBlob: true, |
| isBoolean: true, |
| isPromiseLike: true, |
| trim: true, |
| escapeForRegexp: true, |
| isElement: true, |
| makeMap: true, |
| includes: true, |
| arrayRemove: true, |
| copy: true, |
| shallowCopy: true, |
| equals: true, |
| csp: true, |
| jq: true, |
| concat: true, |
| sliceArgs: true, |
| bind: true, |
| toJsonReplacer: true, |
| toJson: true, |
| fromJson: true, |
| convertTimezoneToLocal: true, |
| timezoneToOffset: true, |
| startingTag: true, |
| tryDecodeURIComponent: true, |
| parseKeyValue: true, |
| toKeyValue: true, |
| encodeUriSegment: true, |
| encodeUriQuery: true, |
| angularInit: true, |
| bootstrap: true, |
| getTestability: true, |
| snake_case: true, |
| bindJQuery: true, |
| assertArg: true, |
| assertArgFn: true, |
| assertNotHasOwnProperty: true, |
| getter: true, |
| getBlockNodes: true, |
| hasOwnProperty: true, |
| createMap: true, |
| |
| NODE_TYPE_ELEMENT: true, |
| NODE_TYPE_ATTRIBUTE: true, |
| NODE_TYPE_TEXT: true, |
| NODE_TYPE_COMMENT: true, |
| NODE_TYPE_DOCUMENT: true, |
| NODE_TYPE_DOCUMENT_FRAGMENT: true, |
| */ |
| |
| //////////////////////////////////// |
| |
| /** |
| * @ngdoc module |
| * @name ng |
| * @module ng |
| * @description |
| * |
| * # ng (core module) |
| * The ng module is loaded by default when an AngularJS application is started. The module itself |
| * contains the essential components for an AngularJS application to function. The table below |
| * lists a high level breakdown of each of the services/factories, filters, directives and testing |
| * components available within this core module. |
| * |
| * <div doc-module-components="ng"></div> |
| */ |
| |
| var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/; |
| |
| // The name of a form control's ValidityState property. |
| // This is used so that it's possible for internal tests to create mock ValidityStates. |
| var VALIDITY_STATE_PROPERTY = 'validity'; |
| |
| /** |
| * @ngdoc function |
| * @name angular.lowercase |
| * @module ng |
| * @kind function |
| * |
| * @description Converts the specified string to lowercase. |
| * @param {string} string String to be converted to lowercase. |
| * @returns {string} Lowercased string. |
| */ |
| var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;}; |
| var hasOwnProperty = Object.prototype.hasOwnProperty; |
| |
| /** |
| * @ngdoc function |
| * @name angular.uppercase |
| * @module ng |
| * @kind function |
| * |
| * @description Converts the specified string to uppercase. |
| * @param {string} string String to be converted to uppercase. |
| * @returns {string} Uppercased string. |
| */ |
| var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;}; |
| |
| |
| var manualLowercase = function(s) { |
| /* jshint bitwise: false */ |
| return isString(s) |
| ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);}) |
| : s; |
| }; |
| var manualUppercase = function(s) { |
| /* jshint bitwise: false */ |
| return isString(s) |
| ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);}) |
| : s; |
| }; |
| |
| |
| // String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish |
| // locale, for this reason we need to detect this case and redefine lowercase/uppercase methods |
| // with correct but slower alternatives. |
| if ('i' !== 'I'.toLowerCase()) { |
| lowercase = manualLowercase; |
| uppercase = manualUppercase; |
| } |
| |
| |
| var |
| msie, // holds major version number for IE, or NaN if UA is not IE. |
| jqLite, // delay binding since jQuery could be loaded after us. |
| jQuery, // delay binding |
| slice = [].slice, |
| splice = [].splice, |
| push = [].push, |
| toString = Object.prototype.toString, |
| getPrototypeOf = Object.getPrototypeOf, |
| ngMinErr = minErr('ng'), |
| |
| /** @name angular */ |
| angular = window.angular || (window.angular = {}), |
| angularModule, |
| uid = 0; |
| |
| /** |
| * documentMode is an IE-only property |
| * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx |
| */ |
| msie = document.documentMode; |
| |
| |
| /** |
| * @private |
| * @param {*} obj |
| * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments, |
| * String ...) |
| */ |
| function isArrayLike(obj) { |
| if (obj == null || isWindow(obj)) { |
| return false; |
| } |
| |
| // Support: iOS 8.2 (not reproducible in simulator) |
| // "length" in obj used to prevent JIT error (gh-11508) |
| var length = "length" in Object(obj) && obj.length; |
| |
| if (obj.nodeType === NODE_TYPE_ELEMENT && length) { |
| return true; |
| } |
| |
| return isString(obj) || isArray(obj) || length === 0 || |
| typeof length === 'number' && length > 0 && (length - 1) in obj; |
| } |
| |
| /** |
| * @ngdoc function |
| * @name angular.forEach |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Invokes the `iterator` function once for each item in `obj` collection, which can be either an |
| * object or an array. The `iterator` function is invoked with `iterator(value, key, obj)`, where `value` |
| * is the value of an object property or an array element, `key` is the object property key or |
| * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional. |
| * |
| * It is worth noting that `.forEach` does not iterate over inherited properties because it filters |
| * using the `hasOwnProperty` method. |
| * |
| * Unlike ES262's |
| * [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18), |
| * Providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just |
| * return the value provided. |
| * |
| ```js |
| var values = {name: 'misko', gender: 'male'}; |
| var log = []; |
| angular.forEach(values, function(value, key) { |
| this.push(key + ': ' + value); |
| }, log); |
| expect(log).toEqual(['name: misko', 'gender: male']); |
| ``` |
| * |
| * @param {Object|Array} obj Object to iterate over. |
| * @param {Function} iterator Iterator function. |
| * @param {Object=} context Object to become context (`this`) for the iterator function. |
| * @returns {Object|Array} Reference to `obj`. |
| */ |
| |
| function forEach(obj, iterator, context) { |
| var key, length; |
| if (obj) { |
| if (isFunction(obj)) { |
| for (key in obj) { |
| // Need to check if hasOwnProperty exists, |
| // as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function |
| if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) { |
| iterator.call(context, obj[key], key, obj); |
| } |
| } |
| } else if (isArray(obj) || isArrayLike(obj)) { |
| var isPrimitive = typeof obj !== 'object'; |
| for (key = 0, length = obj.length; key < length; key++) { |
| if (isPrimitive || key in obj) { |
| iterator.call(context, obj[key], key, obj); |
| } |
| } |
| } else if (obj.forEach && obj.forEach !== forEach) { |
| obj.forEach(iterator, context, obj); |
| } else if (isBlankObject(obj)) { |
| // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty |
| for (key in obj) { |
| iterator.call(context, obj[key], key, obj); |
| } |
| } else if (typeof obj.hasOwnProperty === 'function') { |
| // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed |
| for (key in obj) { |
| if (obj.hasOwnProperty(key)) { |
| iterator.call(context, obj[key], key, obj); |
| } |
| } |
| } else { |
| // Slow path for objects which do not have a method `hasOwnProperty` |
| for (key in obj) { |
| if (hasOwnProperty.call(obj, key)) { |
| iterator.call(context, obj[key], key, obj); |
| } |
| } |
| } |
| } |
| return obj; |
| } |
| |
| function forEachSorted(obj, iterator, context) { |
| var keys = Object.keys(obj).sort(); |
| for (var i = 0; i < keys.length; i++) { |
| iterator.call(context, obj[keys[i]], keys[i]); |
| } |
| return keys; |
| } |
| |
| |
| /** |
| * when using forEach the params are value, key, but it is often useful to have key, value. |
| * @param {function(string, *)} iteratorFn |
| * @returns {function(*, string)} |
| */ |
| function reverseParams(iteratorFn) { |
| return function(value, key) { iteratorFn(key, value); }; |
| } |
| |
| /** |
| * A consistent way of creating unique IDs in angular. |
| * |
| * Using simple numbers allows us to generate 28.6 million unique ids per second for 10 years before |
| * we hit number precision issues in JavaScript. |
| * |
| * Math.pow(2,53) / 60 / 60 / 24 / 365 / 10 = 28.6M |
| * |
| * @returns {number} an unique alpha-numeric string |
| */ |
| function nextUid() { |
| return ++uid; |
| } |
| |
| |
| /** |
| * Set or clear the hashkey for an object. |
| * @param obj object |
| * @param h the hashkey (!truthy to delete the hashkey) |
| */ |
| function setHashKey(obj, h) { |
| if (h) { |
| obj.$$hashKey = h; |
| } else { |
| delete obj.$$hashKey; |
| } |
| } |
| |
| |
| function baseExtend(dst, objs, deep) { |
| var h = dst.$$hashKey; |
| |
| for (var i = 0, ii = objs.length; i < ii; ++i) { |
| var obj = objs[i]; |
| if (!isObject(obj) && !isFunction(obj)) continue; |
| var keys = Object.keys(obj); |
| for (var j = 0, jj = keys.length; j < jj; j++) { |
| var key = keys[j]; |
| var src = obj[key]; |
| |
| if (deep && isObject(src)) { |
| if (isDate(src)) { |
| dst[key] = new Date(src.valueOf()); |
| } else if (isRegExp(src)) { |
| dst[key] = new RegExp(src); |
| } else { |
| if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {}; |
| baseExtend(dst[key], [src], true); |
| } |
| } else { |
| dst[key] = src; |
| } |
| } |
| } |
| |
| setHashKey(dst, h); |
| return dst; |
| } |
| |
| /** |
| * @ngdoc function |
| * @name angular.extend |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s) |
| * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so |
| * by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`. |
| * |
| * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use |
| * {@link angular.merge} for this. |
| * |
| * @param {Object} dst Destination object. |
| * @param {...Object} src Source object(s). |
| * @returns {Object} Reference to `dst`. |
| */ |
| function extend(dst) { |
| return baseExtend(dst, slice.call(arguments, 1), false); |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.merge |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s) |
| * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so |
| * by passing an empty object as the target: `var object = angular.merge({}, object1, object2)`. |
| * |
| * Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source |
| * objects, performing a deep copy. |
| * |
| * @param {Object} dst Destination object. |
| * @param {...Object} src Source object(s). |
| * @returns {Object} Reference to `dst`. |
| */ |
| function merge(dst) { |
| return baseExtend(dst, slice.call(arguments, 1), true); |
| } |
| |
| |
| |
| function toInt(str) { |
| return parseInt(str, 10); |
| } |
| |
| |
| function inherit(parent, extra) { |
| return extend(Object.create(parent), extra); |
| } |
| |
| /** |
| * @ngdoc function |
| * @name angular.noop |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * A function that performs no operations. This function can be useful when writing code in the |
| * functional style. |
| ```js |
| function foo(callback) { |
| var result = calculateResult(); |
| (callback || angular.noop)(result); |
| } |
| ``` |
| */ |
| function noop() {} |
| noop.$inject = []; |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.identity |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * A function that returns its first argument. This function is useful when writing code in the |
| * functional style. |
| * |
| ```js |
| function transformer(transformationFn, value) { |
| return (transformationFn || angular.identity)(value); |
| }; |
| ``` |
| * @param {*} value to be returned. |
| * @returns {*} the value passed in. |
| */ |
| function identity($) {return $;} |
| identity.$inject = []; |
| |
| |
| function valueFn(value) {return function() {return value;};} |
| |
| function hasCustomToString(obj) { |
| return isFunction(obj.toString) && obj.toString !== Object.prototype.toString; |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isUndefined |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is undefined. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is undefined. |
| */ |
| function isUndefined(value) {return typeof value === 'undefined';} |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isDefined |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is defined. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is defined. |
| */ |
| function isDefined(value) {return typeof value !== 'undefined';} |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isObject |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not |
| * considered to be objects. Note that JavaScript arrays are objects. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is an `Object` but not `null`. |
| */ |
| function isObject(value) { |
| // http://jsperf.com/isobject4 |
| return value !== null && typeof value === 'object'; |
| } |
| |
| |
| /** |
| * Determine if a value is an object with a null prototype |
| * |
| * @returns {boolean} True if `value` is an `Object` with a null prototype |
| */ |
| function isBlankObject(value) { |
| return value !== null && typeof value === 'object' && !getPrototypeOf(value); |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isString |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is a `String`. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is a `String`. |
| */ |
| function isString(value) {return typeof value === 'string';} |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isNumber |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is a `Number`. |
| * |
| * This includes the "special" numbers `NaN`, `+Infinity` and `-Infinity`. |
| * |
| * If you wish to exclude these then you can use the native |
| * [`isFinite'](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite) |
| * method. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is a `Number`. |
| */ |
| function isNumber(value) {return typeof value === 'number';} |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isDate |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a value is a date. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is a `Date`. |
| */ |
| function isDate(value) { |
| return toString.call(value) === '[object Date]'; |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isArray |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is an `Array`. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is an `Array`. |
| */ |
| var isArray = Array.isArray; |
| |
| /** |
| * @ngdoc function |
| * @name angular.isFunction |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is a `Function`. |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is a `Function`. |
| */ |
| function isFunction(value) {return typeof value === 'function';} |
| |
| |
| /** |
| * Determines if a value is a regular expression object. |
| * |
| * @private |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is a `RegExp`. |
| */ |
| function isRegExp(value) { |
| return toString.call(value) === '[object RegExp]'; |
| } |
| |
| |
| /** |
| * Checks if `obj` is a window object. |
| * |
| * @private |
| * @param {*} obj Object to check |
| * @returns {boolean} True if `obj` is a window obj. |
| */ |
| function isWindow(obj) { |
| return obj && obj.window === obj; |
| } |
| |
| |
| function isScope(obj) { |
| return obj && obj.$evalAsync && obj.$watch; |
| } |
| |
| |
| function isFile(obj) { |
| return toString.call(obj) === '[object File]'; |
| } |
| |
| |
| function isFormData(obj) { |
| return toString.call(obj) === '[object FormData]'; |
| } |
| |
| |
| function isBlob(obj) { |
| return toString.call(obj) === '[object Blob]'; |
| } |
| |
| |
| function isBoolean(value) { |
| return typeof value === 'boolean'; |
| } |
| |
| |
| function isPromiseLike(obj) { |
| return obj && isFunction(obj.then); |
| } |
| |
| |
| var TYPED_ARRAY_REGEXP = /^\[object (Uint8(Clamped)?)|(Uint16)|(Uint32)|(Int8)|(Int16)|(Int32)|(Float(32)|(64))Array\]$/; |
| function isTypedArray(value) { |
| return TYPED_ARRAY_REGEXP.test(toString.call(value)); |
| } |
| |
| |
| var trim = function(value) { |
| return isString(value) ? value.trim() : value; |
| }; |
| |
| // Copied from: |
| // http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021 |
| // Prereq: s is a string. |
| var escapeForRegexp = function(s) { |
| return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1'). |
| replace(/\x08/g, '\\x08'); |
| }; |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.isElement |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if a reference is a DOM element (or wrapped jQuery element). |
| * |
| * @param {*} value Reference to check. |
| * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element). |
| */ |
| function isElement(node) { |
| return !!(node && |
| (node.nodeName // we are a direct element |
| || (node.prop && node.attr && node.find))); // we have an on and find method part of jQuery API |
| } |
| |
| /** |
| * @param str 'key1,key2,...' |
| * @returns {object} in the form of {key1:true, key2:true, ...} |
| */ |
| function makeMap(str) { |
| var obj = {}, items = str.split(","), i; |
| for (i = 0; i < items.length; i++) { |
| obj[items[i]] = true; |
| } |
| return obj; |
| } |
| |
| |
| function nodeName_(element) { |
| return lowercase(element.nodeName || (element[0] && element[0].nodeName)); |
| } |
| |
| function includes(array, obj) { |
| return Array.prototype.indexOf.call(array, obj) != -1; |
| } |
| |
| function arrayRemove(array, value) { |
| var index = array.indexOf(value); |
| if (index >= 0) { |
| array.splice(index, 1); |
| } |
| return index; |
| } |
| |
| /** |
| * @ngdoc function |
| * @name angular.copy |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Creates a deep copy of `source`, which should be an object or an array. |
| * |
| * * If no destination is supplied, a copy of the object or array is created. |
| * * If a destination is provided, all of its elements (for arrays) or properties (for objects) |
| * are deleted and then all elements/properties from the source are copied to it. |
| * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned. |
| * * If `source` is identical to 'destination' an exception will be thrown. |
| * |
| * @param {*} source The source that will be used to make a copy. |
| * Can be any type, including primitives, `null`, and `undefined`. |
| * @param {(Object|Array)=} destination Destination into which the source is copied. If |
| * provided, must be of the same type as `source`. |
| * @returns {*} The copy or updated `destination`, if `destination` was specified. |
| * |
| * @example |
| <example module="copyExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <form novalidate class="simple-form"> |
| Name: <input type="text" ng-model="user.name" /><br /> |
| E-mail: <input type="email" ng-model="user.email" /><br /> |
| Gender: <input type="radio" ng-model="user.gender" value="male" />male |
| <input type="radio" ng-model="user.gender" value="female" />female<br /> |
| <button ng-click="reset()">RESET</button> |
| <button ng-click="update(user)">SAVE</button> |
| </form> |
| <pre>form = {{user | json}}</pre> |
| <pre>master = {{master | json}}</pre> |
| </div> |
| |
| <script> |
| angular.module('copyExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.master= {}; |
| |
| $scope.update = function(user) { |
| // Example with 1 argument |
| $scope.master= angular.copy(user); |
| }; |
| |
| $scope.reset = function() { |
| // Example with 2 arguments |
| angular.copy($scope.master, $scope.user); |
| }; |
| |
| $scope.reset(); |
| }]); |
| </script> |
| </file> |
| </example> |
| */ |
| function copy(source, destination, stackSource, stackDest) { |
| if (isWindow(source) || isScope(source)) { |
| throw ngMinErr('cpws', |
| "Can't copy! Making copies of Window or Scope instances is not supported."); |
| } |
| if (isTypedArray(destination)) { |
| throw ngMinErr('cpta', |
| "Can't copy! TypedArray destination cannot be mutated."); |
| } |
| |
| if (!destination) { |
| destination = source; |
| if (isObject(source)) { |
| var index; |
| if (stackSource && (index = stackSource.indexOf(source)) !== -1) { |
| return stackDest[index]; |
| } |
| |
| // TypedArray, Date and RegExp have specific copy functionality and must be |
| // pushed onto the stack before returning. |
| // Array and other objects create the base object and recurse to copy child |
| // objects. The array/object will be pushed onto the stack when recursed. |
| if (isArray(source)) { |
| return copy(source, [], stackSource, stackDest); |
| } else if (isTypedArray(source)) { |
| destination = new source.constructor(source); |
| } else if (isDate(source)) { |
| destination = new Date(source.getTime()); |
| } else if (isRegExp(source)) { |
| destination = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]); |
| destination.lastIndex = source.lastIndex; |
| } else if (isFunction(source.cloneNode)) { |
| destination = source.cloneNode(true); |
| } else { |
| var emptyObject = Object.create(getPrototypeOf(source)); |
| return copy(source, emptyObject, stackSource, stackDest); |
| } |
| |
| if (stackDest) { |
| stackSource.push(source); |
| stackDest.push(destination); |
| } |
| } |
| } else { |
| if (source === destination) throw ngMinErr('cpi', |
| "Can't copy! Source and destination are identical."); |
| |
| stackSource = stackSource || []; |
| stackDest = stackDest || []; |
| |
| if (isObject(source)) { |
| stackSource.push(source); |
| stackDest.push(destination); |
| } |
| |
| var result, key; |
| if (isArray(source)) { |
| destination.length = 0; |
| for (var i = 0; i < source.length; i++) { |
| destination.push(copy(source[i], null, stackSource, stackDest)); |
| } |
| } else { |
| var h = destination.$$hashKey; |
| if (isArray(destination)) { |
| destination.length = 0; |
| } else { |
| forEach(destination, function(value, key) { |
| delete destination[key]; |
| }); |
| } |
| if (isBlankObject(source)) { |
| // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty |
| for (key in source) { |
| destination[key] = copy(source[key], null, stackSource, stackDest); |
| } |
| } else if (source && typeof source.hasOwnProperty === 'function') { |
| // Slow path, which must rely on hasOwnProperty |
| for (key in source) { |
| if (source.hasOwnProperty(key)) { |
| destination[key] = copy(source[key], null, stackSource, stackDest); |
| } |
| } |
| } else { |
| // Slowest path --- hasOwnProperty can't be called as a method |
| for (key in source) { |
| if (hasOwnProperty.call(source, key)) { |
| destination[key] = copy(source[key], null, stackSource, stackDest); |
| } |
| } |
| } |
| setHashKey(destination,h); |
| } |
| } |
| return destination; |
| } |
| |
| /** |
| * Creates a shallow copy of an object, an array or a primitive. |
| * |
| * Assumes that there are no proto properties for objects. |
| */ |
| function shallowCopy(src, dst) { |
| if (isArray(src)) { |
| dst = dst || []; |
| |
| for (var i = 0, ii = src.length; i < ii; i++) { |
| dst[i] = src[i]; |
| } |
| } else if (isObject(src)) { |
| dst = dst || {}; |
| |
| for (var key in src) { |
| if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) { |
| dst[key] = src[key]; |
| } |
| } |
| } |
| |
| return dst || src; |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.equals |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Determines if two objects or two values are equivalent. Supports value types, regular |
| * expressions, arrays and objects. |
| * |
| * Two objects or values are considered equivalent if at least one of the following is true: |
| * |
| * * Both objects or values pass `===` comparison. |
| * * Both objects or values are of the same type and all of their properties are equal by |
| * comparing them with `angular.equals`. |
| * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal) |
| * * Both values represent the same regular expression (In JavaScript, |
| * /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual |
| * representation matches). |
| * |
| * During a property comparison, properties of `function` type and properties with names |
| * that begin with `$` are ignored. |
| * |
| * Scope and DOMWindow objects are being compared only by identify (`===`). |
| * |
| * @param {*} o1 Object or value to compare. |
| * @param {*} o2 Object or value to compare. |
| * @returns {boolean} True if arguments are equal. |
| */ |
| function equals(o1, o2) { |
| if (o1 === o2) return true; |
| if (o1 === null || o2 === null) return false; |
| if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN |
| var t1 = typeof o1, t2 = typeof o2, length, key, keySet; |
| if (t1 == t2) { |
| if (t1 == 'object') { |
| if (isArray(o1)) { |
| if (!isArray(o2)) return false; |
| if ((length = o1.length) == o2.length) { |
| for (key = 0; key < length; key++) { |
| if (!equals(o1[key], o2[key])) return false; |
| } |
| return true; |
| } |
| } else if (isDate(o1)) { |
| if (!isDate(o2)) return false; |
| return equals(o1.getTime(), o2.getTime()); |
| } else if (isRegExp(o1)) { |
| return isRegExp(o2) ? o1.toString() == o2.toString() : false; |
| } else { |
| if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) || |
| isArray(o2) || isDate(o2) || isRegExp(o2)) return false; |
| keySet = createMap(); |
| for (key in o1) { |
| if (key.charAt(0) === '$' || isFunction(o1[key])) continue; |
| if (!equals(o1[key], o2[key])) return false; |
| keySet[key] = true; |
| } |
| for (key in o2) { |
| if (!(key in keySet) && |
| key.charAt(0) !== '$' && |
| isDefined(o2[key]) && |
| !isFunction(o2[key])) return false; |
| } |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| var csp = function() { |
| if (!isDefined(csp.rules)) { |
| |
| |
| var ngCspElement = (document.querySelector('[ng-csp]') || |
| document.querySelector('[data-ng-csp]')); |
| |
| if (ngCspElement) { |
| var ngCspAttribute = ngCspElement.getAttribute('ng-csp') || |
| ngCspElement.getAttribute('data-ng-csp'); |
| csp.rules = { |
| noUnsafeEval: !ngCspAttribute || (ngCspAttribute.indexOf('no-unsafe-eval') !== -1), |
| noInlineStyle: !ngCspAttribute || (ngCspAttribute.indexOf('no-inline-style') !== -1) |
| }; |
| } else { |
| csp.rules = { |
| noUnsafeEval: noUnsafeEval(), |
| noInlineStyle: false |
| }; |
| } |
| } |
| |
| return csp.rules; |
| |
| function noUnsafeEval() { |
| try { |
| /* jshint -W031, -W054 */ |
| new Function(''); |
| /* jshint +W031, +W054 */ |
| return false; |
| } catch (e) { |
| return true; |
| } |
| } |
| }; |
| |
| /** |
| * @ngdoc directive |
| * @module ng |
| * @name ngJq |
| * |
| * @element ANY |
| * @param {string=} ngJq the name of the library available under `window` |
| * to be used for angular.element |
| * @description |
| * Use this directive to force the angular.element library. This should be |
| * used to force either jqLite by leaving ng-jq blank or setting the name of |
| * the jquery variable under window (eg. jQuery). |
| * |
| * Since angular looks for this directive when it is loaded (doesn't wait for the |
| * DOMContentLoaded event), it must be placed on an element that comes before the script |
| * which loads angular. Also, only the first instance of `ng-jq` will be used and all |
| * others ignored. |
| * |
| * @example |
| * This example shows how to force jqLite using the `ngJq` directive to the `html` tag. |
| ```html |
| <!doctype html> |
| <html ng-app ng-jq> |
| ... |
| ... |
| </html> |
| ``` |
| * @example |
| * This example shows how to use a jQuery based library of a different name. |
| * The library name must be available at the top most 'window'. |
| ```html |
| <!doctype html> |
| <html ng-app ng-jq="jQueryLib"> |
| ... |
| ... |
| </html> |
| ``` |
| */ |
| var jq = function() { |
| if (isDefined(jq.name_)) return jq.name_; |
| var el; |
| var i, ii = ngAttrPrefixes.length, prefix, name; |
| for (i = 0; i < ii; ++i) { |
| prefix = ngAttrPrefixes[i]; |
| if (el = document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) { |
| name = el.getAttribute(prefix + 'jq'); |
| break; |
| } |
| } |
| |
| return (jq.name_ = name); |
| }; |
| |
| function concat(array1, array2, index) { |
| return array1.concat(slice.call(array2, index)); |
| } |
| |
| function sliceArgs(args, startIndex) { |
| return slice.call(args, startIndex || 0); |
| } |
| |
| |
| /* jshint -W101 */ |
| /** |
| * @ngdoc function |
| * @name angular.bind |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for |
| * `fn`). You can supply optional `args` that are prebound to the function. This feature is also |
| * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as |
| * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application). |
| * |
| * @param {Object} self Context which `fn` should be evaluated in. |
| * @param {function()} fn Function to be bound. |
| * @param {...*} args Optional arguments to be prebound to the `fn` function call. |
| * @returns {function()} Function that wraps the `fn` with all the specified bindings. |
| */ |
| /* jshint +W101 */ |
| function bind(self, fn) { |
| var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : []; |
| if (isFunction(fn) && !(fn instanceof RegExp)) { |
| return curryArgs.length |
| ? function() { |
| return arguments.length |
| ? fn.apply(self, concat(curryArgs, arguments, 0)) |
| : fn.apply(self, curryArgs); |
| } |
| : function() { |
| return arguments.length |
| ? fn.apply(self, arguments) |
| : fn.call(self); |
| }; |
| } else { |
| // in IE, native methods are not functions so they cannot be bound (note: they don't need to be) |
| return fn; |
| } |
| } |
| |
| |
| function toJsonReplacer(key, value) { |
| var val = value; |
| |
| if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') { |
| val = undefined; |
| } else if (isWindow(value)) { |
| val = '$WINDOW'; |
| } else if (value && document === value) { |
| val = '$DOCUMENT'; |
| } else if (isScope(value)) { |
| val = '$SCOPE'; |
| } |
| |
| return val; |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.toJson |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be |
| * stripped since angular uses this notation internally. |
| * |
| * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON. |
| * @param {boolean|number} [pretty=2] If set to true, the JSON output will contain newlines and whitespace. |
| * If set to an integer, the JSON output will contain that many spaces per indentation. |
| * @returns {string|undefined} JSON-ified string representing `obj`. |
| */ |
| function toJson(obj, pretty) { |
| if (typeof obj === 'undefined') return undefined; |
| if (!isNumber(pretty)) { |
| pretty = pretty ? 2 : null; |
| } |
| return JSON.stringify(obj, toJsonReplacer, pretty); |
| } |
| |
| |
| /** |
| * @ngdoc function |
| * @name angular.fromJson |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Deserializes a JSON string. |
| * |
| * @param {string} json JSON string to deserialize. |
| * @returns {Object|Array|string|number} Deserialized JSON string. |
| */ |
| function fromJson(json) { |
| return isString(json) |
| ? JSON.parse(json) |
| : json; |
| } |
| |
| |
| function timezoneToOffset(timezone, fallback) { |
| var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000; |
| return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset; |
| } |
| |
| |
| function addDateMinutes(date, minutes) { |
| date = new Date(date.getTime()); |
| date.setMinutes(date.getMinutes() + minutes); |
| return date; |
| } |
| |
| |
| function convertTimezoneToLocal(date, timezone, reverse) { |
| reverse = reverse ? -1 : 1; |
| var timezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset()); |
| return addDateMinutes(date, reverse * (timezoneOffset - date.getTimezoneOffset())); |
| } |
| |
| |
| /** |
| * @returns {string} Returns the string representation of the element. |
| */ |
| function startingTag(element) { |
| element = jqLite(element).clone(); |
| try { |
| // turns out IE does not let you set .html() on elements which |
| // are not allowed to have children. So we just ignore it. |
| element.empty(); |
| } catch (e) {} |
| var elemHtml = jqLite('<div>').append(element).html(); |
| try { |
| return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) : |
| elemHtml. |
| match(/^(<[^>]+>)/)[1]. |
| replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); }); |
| } catch (e) { |
| return lowercase(elemHtml); |
| } |
| |
| } |
| |
| |
| ///////////////////////////////////////////////// |
| |
| /** |
| * Tries to decode the URI component without throwing an exception. |
| * |
| * @private |
| * @param str value potential URI component to check. |
| * @returns {boolean} True if `value` can be decoded |
| * with the decodeURIComponent function. |
| */ |
| function tryDecodeURIComponent(value) { |
| try { |
| return decodeURIComponent(value); |
| } catch (e) { |
| // Ignore any invalid uri component |
| } |
| } |
| |
| |
| /** |
| * Parses an escaped url query string into key-value pairs. |
| * @returns {Object.<string,boolean|Array>} |
| */ |
| function parseKeyValue(/**string*/keyValue) { |
| var obj = {}; |
| forEach((keyValue || "").split('&'), function(keyValue) { |
| var splitPoint, key, val; |
| if (keyValue) { |
| key = keyValue = keyValue.replace(/\+/g,'%20'); |
| splitPoint = keyValue.indexOf('='); |
| if (splitPoint !== -1) { |
| key = keyValue.substring(0, splitPoint); |
| val = keyValue.substring(splitPoint + 1); |
| } |
| key = tryDecodeURIComponent(key); |
| if (isDefined(key)) { |
| val = isDefined(val) ? tryDecodeURIComponent(val) : true; |
| if (!hasOwnProperty.call(obj, key)) { |
| obj[key] = val; |
| } else if (isArray(obj[key])) { |
| obj[key].push(val); |
| } else { |
| obj[key] = [obj[key],val]; |
| } |
| } |
| } |
| }); |
| return obj; |
| } |
| |
| function toKeyValue(obj) { |
| var parts = []; |
| forEach(obj, function(value, key) { |
| if (isArray(value)) { |
| forEach(value, function(arrayValue) { |
| parts.push(encodeUriQuery(key, true) + |
| (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true))); |
| }); |
| } else { |
| parts.push(encodeUriQuery(key, true) + |
| (value === true ? '' : '=' + encodeUriQuery(value, true))); |
| } |
| }); |
| return parts.length ? parts.join('&') : ''; |
| } |
| |
| |
| /** |
| * We need our custom method because encodeURIComponent is too aggressive and doesn't follow |
| * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path |
| * segments: |
| * segment = *pchar |
| * pchar = unreserved / pct-encoded / sub-delims / ":" / "@" |
| * pct-encoded = "%" HEXDIG HEXDIG |
| * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" |
| * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" |
| * / "*" / "+" / "," / ";" / "=" |
| */ |
| function encodeUriSegment(val) { |
| return encodeUriQuery(val, true). |
| replace(/%26/gi, '&'). |
| replace(/%3D/gi, '='). |
| replace(/%2B/gi, '+'); |
| } |
| |
| |
| /** |
| * This method is intended for encoding *key* or *value* parts of query component. We need a custom |
| * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be |
| * encoded per http://tools.ietf.org/html/rfc3986: |
| * query = *( pchar / "/" / "?" ) |
| * pchar = unreserved / pct-encoded / sub-delims / ":" / "@" |
| * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" |
| * pct-encoded = "%" HEXDIG HEXDIG |
| * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" |
| * / "*" / "+" / "," / ";" / "=" |
| */ |
| function encodeUriQuery(val, pctEncodeSpaces) { |
| return encodeURIComponent(val). |
| replace(/%40/gi, '@'). |
| replace(/%3A/gi, ':'). |
| replace(/%24/g, '$'). |
| replace(/%2C/gi, ','). |
| replace(/%3B/gi, ';'). |
| replace(/%20/g, (pctEncodeSpaces ? '%20' : '+')); |
| } |
| |
| var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-']; |
| |
| function getNgAttribute(element, ngAttr) { |
| var attr, i, ii = ngAttrPrefixes.length; |
| for (i = 0; i < ii; ++i) { |
| attr = ngAttrPrefixes[i] + ngAttr; |
| if (isString(attr = element.getAttribute(attr))) { |
| return attr; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name ngApp |
| * @module ng |
| * |
| * @element ANY |
| * @param {angular.Module} ngApp an optional application |
| * {@link angular.module module} name to load. |
| * @param {boolean=} ngStrictDi if this attribute is present on the app element, the injector will be |
| * created in "strict-di" mode. This means that the application will fail to invoke functions which |
| * do not use explicit function annotation (and are thus unsuitable for minification), as described |
| * in {@link guide/di the Dependency Injection guide}, and useful debugging info will assist in |
| * tracking down the root of these bugs. |
| * |
| * @description |
| * |
| * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive |
| * designates the **root element** of the application and is typically placed near the root element |
| * of the page - e.g. on the `<body>` or `<html>` tags. |
| * |
| * Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp` |
| * found in the document will be used to define the root element to auto-bootstrap as an |
| * application. To run multiple applications in an HTML document you must manually bootstrap them using |
| * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other. |
| * |
| * You can specify an **AngularJS module** to be used as the root module for the application. This |
| * module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It |
| * should contain the application code needed or have dependencies on other modules that will |
| * contain the code. See {@link angular.module} for more information. |
| * |
| * In the example below if the `ngApp` directive were not placed on the `html` element then the |
| * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}` |
| * would not be resolved to `3`. |
| * |
| * `ngApp` is the easiest, and most common way to bootstrap an application. |
| * |
| <example module="ngAppDemo"> |
| <file name="index.html"> |
| <div ng-controller="ngAppDemoController"> |
| I can add: {{a}} + {{b}} = {{ a+b }} |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) { |
| $scope.a = 1; |
| $scope.b = 2; |
| }); |
| </file> |
| </example> |
| * |
| * Using `ngStrictDi`, you would see something like this: |
| * |
| <example ng-app-included="true"> |
| <file name="index.html"> |
| <div ng-app="ngAppStrictDemo" ng-strict-di> |
| <div ng-controller="GoodController1"> |
| I can add: {{a}} + {{b}} = {{ a+b }} |
| |
| <p>This renders because the controller does not fail to |
| instantiate, by using explicit annotation style (see |
| script.js for details) |
| </p> |
| </div> |
| |
| <div ng-controller="GoodController2"> |
| Name: <input ng-model="name"><br /> |
| Hello, {{name}}! |
| |
| <p>This renders because the controller does not fail to |
| instantiate, by using explicit annotation style |
| (see script.js for details) |
| </p> |
| </div> |
| |
| <div ng-controller="BadController"> |
| I can add: {{a}} + {{b}} = {{ a+b }} |
| |
| <p>The controller could not be instantiated, due to relying |
| on automatic function annotations (which are disabled in |
| strict mode). As such, the content of this section is not |
| interpolated, and there should be an error in your web console. |
| </p> |
| </div> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('ngAppStrictDemo', []) |
| // BadController will fail to instantiate, due to relying on automatic function annotation, |
| // rather than an explicit annotation |
| .controller('BadController', function($scope) { |
| $scope.a = 1; |
| $scope.b = 2; |
| }) |
| // Unlike BadController, GoodController1 and GoodController2 will not fail to be instantiated, |
| // due to using explicit annotations using the array style and $inject property, respectively. |
| .controller('GoodController1', ['$scope', function($scope) { |
| $scope.a = 1; |
| $scope.b = 2; |
| }]) |
| .controller('GoodController2', GoodController2); |
| function GoodController2($scope) { |
| $scope.name = "World"; |
| } |
| GoodController2.$inject = ['$scope']; |
| </file> |
| <file name="style.css"> |
| div[ng-controller] { |
| margin-bottom: 1em; |
| -webkit-border-radius: 4px; |
| border-radius: 4px; |
| border: 1px solid; |
| padding: .5em; |
| } |
| div[ng-controller^=Good] { |
| border-color: #d6e9c6; |
| background-color: #dff0d8; |
| color: #3c763d; |
| } |
| div[ng-controller^=Bad] { |
| border-color: #ebccd1; |
| background-color: #f2dede; |
| color: #a94442; |
| margin-bottom: 0; |
| } |
| </file> |
| </example> |
| */ |
| function angularInit(element, bootstrap) { |
| var appElement, |
| module, |
| config = {}; |
| |
| // The element `element` has priority over any other element |
| forEach(ngAttrPrefixes, function(prefix) { |
| var name = prefix + 'app'; |
| |
| if (!appElement && element.hasAttribute && element.hasAttribute(name)) { |
| appElement = element; |
| module = element.getAttribute(name); |
| } |
| }); |
| forEach(ngAttrPrefixes, function(prefix) { |
| var name = prefix + 'app'; |
| var candidate; |
| |
| if (!appElement && (candidate = element.querySelector('[' + name.replace(':', '\\:') + ']'))) { |
| appElement = candidate; |
| module = candidate.getAttribute(name); |
| } |
| }); |
| if (appElement) { |
| config.strictDi = getNgAttribute(appElement, "strict-di") !== null; |
| bootstrap(appElement, module ? [module] : [], config); |
| } |
| } |
| |
| /** |
| * @ngdoc function |
| * @name angular.bootstrap |
| * @module ng |
| * @description |
| * Use this function to manually start up angular application. |
| * |
| * See: {@link guide/bootstrap Bootstrap} |
| * |
| * Note that Protractor based end-to-end tests cannot use this function to bootstrap manually. |
| * They must use {@link ng.directive:ngApp ngApp}. |
| * |
| * Angular will detect if it has been loaded into the browser more than once and only allow the |
| * first loaded script to be bootstrapped and will report a warning to the browser console for |
| * each of the subsequent scripts. This prevents strange results in applications, where otherwise |
| * multiple instances of Angular try to work on the DOM. |
| * |
| * ```html |
| * <!doctype html> |
| * <html> |
| * <body> |
| * <div ng-controller="WelcomeController"> |
| * {{greeting}} |
| * </div> |
| * |
| * <script src="angular.js"></script> |
| * <script> |
| * var app = angular.module('demo', []) |
| * .controller('WelcomeController', function($scope) { |
| * $scope.greeting = 'Welcome!'; |
| * }); |
| * angular.bootstrap(document, ['demo']); |
| * </script> |
| * </body> |
| * </html> |
| * ``` |
| * |
| * @param {DOMElement} element DOM element which is the root of angular application. |
| * @param {Array<String|Function|Array>=} modules an array of modules to load into the application. |
| * Each item in the array should be the name of a predefined module or a (DI annotated) |
| * function that will be invoked by the injector as a `config` block. |
| * See: {@link angular.module modules} |
| * @param {Object=} config an object for defining configuration options for the application. The |
| * following keys are supported: |
| * |
| * * `strictDi` - disable automatic function annotation for the application. This is meant to |
| * assist in finding bugs which break minified code. Defaults to `false`. |
| * |
| * @returns {auto.$injector} Returns the newly created injector for this app. |
| */ |
| function bootstrap(element, modules, config) { |
| if (!isObject(config)) config = {}; |
| var defaultConfig = { |
| strictDi: false |
| }; |
| config = extend(defaultConfig, config); |
| var doBootstrap = function() { |
| element = jqLite(element); |
| |
| if (element.injector()) { |
| var tag = (element[0] === document) ? 'document' : startingTag(element); |
| //Encode angle brackets to prevent input from being sanitized to empty string #8683 |
| throw ngMinErr( |
| 'btstrpd', |
| "App Already Bootstrapped with this Element '{0}'", |
| tag.replace(/</,'<').replace(/>/,'>')); |
| } |
| |
| modules = modules || []; |
| modules.unshift(['$provide', function($provide) { |
| $provide.value('$rootElement', element); |
| }]); |
| |
| if (config.debugInfoEnabled) { |
| // Pushing so that this overrides `debugInfoEnabled` setting defined in user's `modules`. |
| modules.push(['$compileProvider', function($compileProvider) { |
| $compileProvider.debugInfoEnabled(true); |
| }]); |
| } |
| |
| modules.unshift('ng'); |
| var injector = createInjector(modules, config.strictDi); |
| injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector', |
| function bootstrapApply(scope, element, compile, injector) { |
| scope.$apply(function() { |
| element.data('$injector', injector); |
| compile(element)(scope); |
| }); |
| }] |
| ); |
| return injector; |
| }; |
| |
| var NG_ENABLE_DEBUG_INFO = /^NG_ENABLE_DEBUG_INFO!/; |
| var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/; |
| |
| if (window && NG_ENABLE_DEBUG_INFO.test(window.name)) { |
| config.debugInfoEnabled = true; |
| window.name = window.name.replace(NG_ENABLE_DEBUG_INFO, ''); |
| } |
| |
| if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) { |
| return doBootstrap(); |
| } |
| |
| window.name = window.name.replace(NG_DEFER_BOOTSTRAP, ''); |
| angular.resumeBootstrap = function(extraModules) { |
| forEach(extraModules, function(module) { |
| modules.push(module); |
| }); |
| return doBootstrap(); |
| }; |
| |
| if (isFunction(angular.resumeDeferredBootstrap)) { |
| angular.resumeDeferredBootstrap(); |
| } |
| } |
| |
| /** |
| * @ngdoc function |
| * @name angular.reloadWithDebugInfo |
| * @module ng |
| * @description |
| * Use this function to reload the current application with debug information turned on. |
| * This takes precedence over a call to `$compileProvider.debugInfoEnabled(false)`. |
| * |
| * See {@link ng.$compileProvider#debugInfoEnabled} for more. |
| */ |
| function reloadWithDebugInfo() { |
| window.name = 'NG_ENABLE_DEBUG_INFO!' + window.name; |
| window.location.reload(); |
| } |
| |
| /** |
| * @name angular.getTestability |
| * @module ng |
| * @description |
| * Get the testability service for the instance of Angular on the given |
| * element. |
| * @param {DOMElement} element DOM element which is the root of angular application. |
| */ |
| function getTestability(rootElement) { |
| var injector = angular.element(rootElement).injector(); |
| if (!injector) { |
| throw ngMinErr('test', |
| 'no injector found for element argument to getTestability'); |
| } |
| return injector.get('$$testability'); |
| } |
| |
| var SNAKE_CASE_REGEXP = /[A-Z]/g; |
| function snake_case(name, separator) { |
| separator = separator || '_'; |
| return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) { |
| return (pos ? separator : '') + letter.toLowerCase(); |
| }); |
| } |
| |
| var bindJQueryFired = false; |
| var skipDestroyOnNextJQueryCleanData; |
| function bindJQuery() { |
| var originalCleanData; |
| |
| if (bindJQueryFired) { |
| return; |
| } |
| |
| // bind to jQuery if present; |
| var jqName = jq(); |
| jQuery = isUndefined(jqName) ? window.jQuery : // use jQuery (if present) |
| !jqName ? undefined : // use jqLite |
| window[jqName]; // use jQuery specified by `ngJq` |
| |
| // Use jQuery if it exists with proper functionality, otherwise default to us. |
| // Angular 1.2+ requires jQuery 1.7+ for on()/off() support. |
| // Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older |
| // versions. It will not work for sure with jQuery <1.7, though. |
| if (jQuery && jQuery.fn.on) { |
| jqLite = jQuery; |
| extend(jQuery.fn, { |
| scope: JQLitePrototype.scope, |
| isolateScope: JQLitePrototype.isolateScope, |
| controller: JQLitePrototype.controller, |
| injector: JQLitePrototype.injector, |
| inheritedData: JQLitePrototype.inheritedData |
| }); |
| |
| // All nodes removed from the DOM via various jQuery APIs like .remove() |
| // are passed through jQuery.cleanData. Monkey-patch this method to fire |
| // the $destroy event on all removed nodes. |
| originalCleanData = jQuery.cleanData; |
| jQuery.cleanData = function(elems) { |
| var events; |
| if (!skipDestroyOnNextJQueryCleanData) { |
| for (var i = 0, elem; (elem = elems[i]) != null; i++) { |
| events = jQuery._data(elem, "events"); |
| if (events && events.$destroy) { |
| jQuery(elem).triggerHandler('$destroy'); |
| } |
| } |
| } else { |
| skipDestroyOnNextJQueryCleanData = false; |
| } |
| originalCleanData(elems); |
| }; |
| } else { |
| jqLite = JQLite; |
| } |
| |
| angular.element = jqLite; |
| |
| // Prevent double-proxying. |
| bindJQueryFired = true; |
| } |
| |
| /** |
| * throw error if the argument is falsy. |
| */ |
| function assertArg(arg, name, reason) { |
| if (!arg) { |
| throw ngMinErr('areq', "Argument '{0}' is {1}", (name || '?'), (reason || "required")); |
| } |
| return arg; |
| } |
| |
| function assertArgFn(arg, name, acceptArrayAnnotation) { |
| if (acceptArrayAnnotation && isArray(arg)) { |
| arg = arg[arg.length - 1]; |
| } |
| |
| assertArg(isFunction(arg), name, 'not a function, got ' + |
| (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg)); |
| return arg; |
| } |
| |
| /** |
| * throw error if the name given is hasOwnProperty |
| * @param {String} name the name to test |
| * @param {String} context the context in which the name is used, such as module or directive |
| */ |
| function assertNotHasOwnProperty(name, context) { |
| if (name === 'hasOwnProperty') { |
| throw ngMinErr('badname', "hasOwnProperty is not a valid {0} name", context); |
| } |
| } |
| |
| /** |
| * Return the value accessible from the object by path. Any undefined traversals are ignored |
| * @param {Object} obj starting object |
| * @param {String} path path to traverse |
| * @param {boolean} [bindFnToScope=true] |
| * @returns {Object} value as accessible by path |
| */ |
| //TODO(misko): this function needs to be removed |
| function getter(obj, path, bindFnToScope) { |
| if (!path) return obj; |
| var keys = path.split('.'); |
| var key; |
| var lastInstance = obj; |
| var len = keys.length; |
| |
| for (var i = 0; i < len; i++) { |
| key = keys[i]; |
| if (obj) { |
| obj = (lastInstance = obj)[key]; |
| } |
| } |
| if (!bindFnToScope && isFunction(obj)) { |
| return bind(lastInstance, obj); |
| } |
| return obj; |
| } |
| |
| /** |
| * Return the DOM siblings between the first and last node in the given array. |
| * @param {Array} array like object |
| * @returns {Array} the inputted object or a jqLite collection containing the nodes |
| */ |
| function getBlockNodes(nodes) { |
| // TODO(perf): update `nodes` instead of creating a new object? |
| var node = nodes[0]; |
| var endNode = nodes[nodes.length - 1]; |
| var blockNodes; |
| |
| for (var i = 1; node !== endNode && (node = node.nextSibling); i++) { |
| if (blockNodes || nodes[i] !== node) { |
| if (!blockNodes) { |
| blockNodes = jqLite(slice.call(nodes, 0, i)); |
| } |
| blockNodes.push(node); |
| } |
| } |
| |
| return blockNodes || nodes; |
| } |
| |
| |
| /** |
| * Creates a new object without a prototype. This object is useful for lookup without having to |
| * guard against prototypically inherited properties via hasOwnProperty. |
| * |
| * Related micro-benchmarks: |
| * - http://jsperf.com/object-create2 |
| * - http://jsperf.com/proto-map-lookup/2 |
| * - http://jsperf.com/for-in-vs-object-keys2 |
| * |
| * @returns {Object} |
| */ |
| function createMap() { |
| return Object.create(null); |
| } |
| |
| var NODE_TYPE_ELEMENT = 1; |
| var NODE_TYPE_ATTRIBUTE = 2; |
| var NODE_TYPE_TEXT = 3; |
| var NODE_TYPE_COMMENT = 8; |
| var NODE_TYPE_DOCUMENT = 9; |
| var NODE_TYPE_DOCUMENT_FRAGMENT = 11; |
| |
| /** |
| * @ngdoc type |
| * @name angular.Module |
| * @module ng |
| * @description |
| * |
| * Interface for configuring angular {@link angular.module modules}. |
| */ |
| |
| function setupModuleLoader(window) { |
| |
| var $injectorMinErr = minErr('$injector'); |
| var ngMinErr = minErr('ng'); |
| |
| function ensure(obj, name, factory) { |
| return obj[name] || (obj[name] = factory()); |
| } |
| |
| var angular = ensure(window, 'angular', Object); |
| |
| // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap |
| angular.$$minErr = angular.$$minErr || minErr; |
| |
| return ensure(angular, 'module', function() { |
| /** @type {Object.<string, angular.Module>} */ |
| var modules = {}; |
| |
| /** |
| * @ngdoc function |
| * @name angular.module |
| * @module ng |
| * @description |
| * |
| * The `angular.module` is a global place for creating, registering and retrieving Angular |
| * modules. |
| * All modules (angular core or 3rd party) that should be available to an application must be |
| * registered using this mechanism. |
| * |
| * Passing one argument retrieves an existing {@link angular.Module}, |
| * whereas passing more than one argument creates a new {@link angular.Module} |
| * |
| * |
| * # Module |
| * |
| * A module is a collection of services, directives, controllers, filters, and configuration information. |
| * `angular.module` is used to configure the {@link auto.$injector $injector}. |
| * |
| * ```js |
| * // Create a new module |
| * var myModule = angular.module('myModule', []); |
| * |
| * // register a new service |
| * myModule.value('appName', 'MyCoolApp'); |
| * |
| * // configure existing services inside initialization blocks. |
| * myModule.config(['$locationProvider', function($locationProvider) { |
| * // Configure existing providers |
| * $locationProvider.hashPrefix('!'); |
| * }]); |
| * ``` |
| * |
| * Then you can create an injector and load your modules like this: |
| * |
| * ```js |
| * var injector = angular.injector(['ng', 'myModule']) |
| * ``` |
| * |
| * However it's more likely that you'll just use |
| * {@link ng.directive:ngApp ngApp} or |
| * {@link angular.bootstrap} to simplify this process for you. |
| * |
| * @param {!string} name The name of the module to create or retrieve. |
| * @param {!Array.<string>=} requires If specified then new module is being created. If |
| * unspecified then the module is being retrieved for further configuration. |
| * @param {Function=} configFn Optional configuration function for the module. Same as |
| * {@link angular.Module#config Module#config()}. |
| * @returns {module} new module with the {@link angular.Module} api. |
| */ |
| return function module(name, requires, configFn) { |
| var assertNotHasOwnProperty = function(name, context) { |
| if (name === 'hasOwnProperty') { |
| throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context); |
| } |
| }; |
| |
| assertNotHasOwnProperty(name, 'module'); |
| if (requires && modules.hasOwnProperty(name)) { |
| modules[name] = null; |
| } |
| return ensure(modules, name, function() { |
| if (!requires) { |
| throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " + |
| "the module name or forgot to load it. If registering a module ensure that you " + |
| "specify the dependencies as the second argument.", name); |
| } |
| |
| /** @type {!Array.<Array.<*>>} */ |
| var invokeQueue = []; |
| |
| /** @type {!Array.<Function>} */ |
| var configBlocks = []; |
| |
| /** @type {!Array.<Function>} */ |
| var runBlocks = []; |
| |
| var config = invokeLater('$injector', 'invoke', 'push', configBlocks); |
| |
| /** @type {angular.Module} */ |
| var moduleInstance = { |
| // Private state |
| _invokeQueue: invokeQueue, |
| _configBlocks: configBlocks, |
| _runBlocks: runBlocks, |
| |
| /** |
| * @ngdoc property |
| * @name angular.Module#requires |
| * @module ng |
| * |
| * @description |
| * Holds the list of modules which the injector will load before the current module is |
| * loaded. |
| */ |
| requires: requires, |
| |
| /** |
| * @ngdoc property |
| * @name angular.Module#name |
| * @module ng |
| * |
| * @description |
| * Name of the module. |
| */ |
| name: name, |
| |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#provider |
| * @module ng |
| * @param {string} name service name |
| * @param {Function} providerType Construction function for creating new instance of the |
| * service. |
| * @description |
| * See {@link auto.$provide#provider $provide.provider()}. |
| */ |
| provider: invokeLaterAndSetModuleName('$provide', 'provider'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#factory |
| * @module ng |
| * @param {string} name service name |
| * @param {Function} providerFunction Function for creating new instance of the service. |
| * @description |
| * See {@link auto.$provide#factory $provide.factory()}. |
| */ |
| factory: invokeLaterAndSetModuleName('$provide', 'factory'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#service |
| * @module ng |
| * @param {string} name service name |
| * @param {Function} constructor A constructor function that will be instantiated. |
| * @description |
| * See {@link auto.$provide#service $provide.service()}. |
| */ |
| service: invokeLaterAndSetModuleName('$provide', 'service'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#value |
| * @module ng |
| * @param {string} name service name |
| * @param {*} object Service instance object. |
| * @description |
| * See {@link auto.$provide#value $provide.value()}. |
| */ |
| value: invokeLater('$provide', 'value'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#constant |
| * @module ng |
| * @param {string} name constant name |
| * @param {*} object Constant value. |
| * @description |
| * Because the constant are fixed, they get applied before other provide methods. |
| * See {@link auto.$provide#constant $provide.constant()}. |
| */ |
| constant: invokeLater('$provide', 'constant', 'unshift'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#decorator |
| * @module ng |
| * @param {string} The name of the service to decorate. |
| * @param {Function} This function will be invoked when the service needs to be |
| * instantiated and should return the decorated service instance. |
| * @description |
| * See {@link auto.$provide#decorator $provide.decorator()}. |
| */ |
| decorator: invokeLaterAndSetModuleName('$provide', 'decorator'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#animation |
| * @module ng |
| * @param {string} name animation name |
| * @param {Function} animationFactory Factory function for creating new instance of an |
| * animation. |
| * @description |
| * |
| * **NOTE**: animations take effect only if the **ngAnimate** module is loaded. |
| * |
| * |
| * Defines an animation hook that can be later used with |
| * {@link $animate $animate} service and directives that use this service. |
| * |
| * ```js |
| * module.animation('.animation-name', function($inject1, $inject2) { |
| * return { |
| * eventName : function(element, done) { |
| * //code to run the animation |
| * //once complete, then run done() |
| * return function cancellationFunction(element) { |
| * //code to cancel the animation |
| * } |
| * } |
| * } |
| * }) |
| * ``` |
| * |
| * See {@link ng.$animateProvider#register $animateProvider.register()} and |
| * {@link ngAnimate ngAnimate module} for more information. |
| */ |
| animation: invokeLaterAndSetModuleName('$animateProvider', 'register'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#filter |
| * @module ng |
| * @param {string} name Filter name - this must be a valid angular expression identifier |
| * @param {Function} filterFactory Factory function for creating new instance of filter. |
| * @description |
| * See {@link ng.$filterProvider#register $filterProvider.register()}. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`. |
| * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace |
| * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores |
| * (`myapp_subsection_filterx`). |
| * </div> |
| */ |
| filter: invokeLaterAndSetModuleName('$filterProvider', 'register'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#controller |
| * @module ng |
| * @param {string|Object} name Controller name, or an object map of controllers where the |
| * keys are the names and the values are the constructors. |
| * @param {Function} constructor Controller constructor function. |
| * @description |
| * See {@link ng.$controllerProvider#register $controllerProvider.register()}. |
| */ |
| controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#directive |
| * @module ng |
| * @param {string|Object} name Directive name, or an object map of directives where the |
| * keys are the names and the values are the factories. |
| * @param {Function} directiveFactory Factory function for creating new instance of |
| * directives. |
| * @description |
| * See {@link ng.$compileProvider#directive $compileProvider.directive()}. |
| */ |
| directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'), |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#config |
| * @module ng |
| * @param {Function} configFn Execute this function on module load. Useful for service |
| * configuration. |
| * @description |
| * Use this method to register work which needs to be performed on module loading. |
| * For more about how to configure services, see |
| * {@link providers#provider-recipe Provider Recipe}. |
| */ |
| config: config, |
| |
| /** |
| * @ngdoc method |
| * @name angular.Module#run |
| * @module ng |
| * @param {Function} initializationFn Execute this function after injector creation. |
| * Useful for application initialization. |
| * @description |
| * Use this method to register work which should be performed when the injector is done |
| * loading all modules. |
| */ |
| run: function(block) { |
| runBlocks.push(block); |
| return this; |
| } |
| }; |
| |
| if (configFn) { |
| config(configFn); |
| } |
| |
| return moduleInstance; |
| |
| /** |
| * @param {string} provider |
| * @param {string} method |
| * @param {String=} insertMethod |
| * @returns {angular.Module} |
| */ |
| function invokeLater(provider, method, insertMethod, queue) { |
| if (!queue) queue = invokeQueue; |
| return function() { |
| queue[insertMethod || 'push']([provider, method, arguments]); |
| return moduleInstance; |
| }; |
| } |
| |
| /** |
| * @param {string} provider |
| * @param {string} method |
| * @returns {angular.Module} |
| */ |
| function invokeLaterAndSetModuleName(provider, method) { |
| return function(recipeName, factoryFunction) { |
| if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name; |
| invokeQueue.push([provider, method, arguments]); |
| return moduleInstance; |
| }; |
| } |
| }); |
| }; |
| }); |
| |
| } |
| |
| /* global: toDebugString: true */ |
| |
| function serializeObject(obj) { |
| var seen = []; |
| |
| return JSON.stringify(obj, function(key, val) { |
| val = toJsonReplacer(key, val); |
| if (isObject(val)) { |
| |
| if (seen.indexOf(val) >= 0) return '...'; |
| |
| seen.push(val); |
| } |
| return val; |
| }); |
| } |
| |
| function toDebugString(obj) { |
| if (typeof obj === 'function') { |
| return obj.toString().replace(/ \{[\s\S]*$/, ''); |
| } else if (isUndefined(obj)) { |
| return 'undefined'; |
| } else if (typeof obj !== 'string') { |
| return serializeObject(obj); |
| } |
| return obj; |
| } |
| |
| /* global angularModule: true, |
| version: true, |
| |
| $CompileProvider, |
| |
| htmlAnchorDirective, |
| inputDirective, |
| inputDirective, |
| formDirective, |
| scriptDirective, |
| selectDirective, |
| styleDirective, |
| optionDirective, |
| ngBindDirective, |
| ngBindHtmlDirective, |
| ngBindTemplateDirective, |
| ngClassDirective, |
| ngClassEvenDirective, |
| ngClassOddDirective, |
| ngCloakDirective, |
| ngControllerDirective, |
| ngFormDirective, |
| ngHideDirective, |
| ngIfDirective, |
| ngIncludeDirective, |
| ngIncludeFillContentDirective, |
| ngInitDirective, |
| ngNonBindableDirective, |
| ngPluralizeDirective, |
| ngRepeatDirective, |
| ngShowDirective, |
| ngStyleDirective, |
| ngSwitchDirective, |
| ngSwitchWhenDirective, |
| ngSwitchDefaultDirective, |
| ngOptionsDirective, |
| ngTranscludeDirective, |
| ngModelDirective, |
| ngListDirective, |
| ngChangeDirective, |
| patternDirective, |
| patternDirective, |
| requiredDirective, |
| requiredDirective, |
| minlengthDirective, |
| minlengthDirective, |
| maxlengthDirective, |
| maxlengthDirective, |
| ngValueDirective, |
| ngModelOptionsDirective, |
| ngAttributeAliasDirectives, |
| ngEventDirectives, |
| |
| $AnchorScrollProvider, |
| $AnimateProvider, |
| $CoreAnimateCssProvider, |
| $$CoreAnimateQueueProvider, |
| $$CoreAnimateRunnerProvider, |
| $BrowserProvider, |
| $CacheFactoryProvider, |
| $ControllerProvider, |
| $DocumentProvider, |
| $ExceptionHandlerProvider, |
| $FilterProvider, |
| $$ForceReflowProvider, |
| $InterpolateProvider, |
| $IntervalProvider, |
| $$HashMapProvider, |
| $HttpProvider, |
| $HttpParamSerializerProvider, |
| $HttpParamSerializerJQLikeProvider, |
| $HttpBackendProvider, |
| $xhrFactoryProvider, |
| $LocationProvider, |
| $LogProvider, |
| $ParseProvider, |
| $RootScopeProvider, |
| $QProvider, |
| $$QProvider, |
| $$SanitizeUriProvider, |
| $SceProvider, |
| $SceDelegateProvider, |
| $SnifferProvider, |
| $TemplateCacheProvider, |
| $TemplateRequestProvider, |
| $$TestabilityProvider, |
| $TimeoutProvider, |
| $$RAFProvider, |
| $WindowProvider, |
| $$jqLiteProvider, |
| $$CookieReaderProvider |
| */ |
| |
| |
| /** |
| * @ngdoc object |
| * @name angular.version |
| * @module ng |
| * @description |
| * An object that contains information about the current AngularJS version. |
| * |
| * This object has the following properties: |
| * |
| * - `full` – `{string}` – Full version string, such as "0.9.18". |
| * - `major` – `{number}` – Major version number, such as "0". |
| * - `minor` – `{number}` – Minor version number, such as "9". |
| * - `dot` – `{number}` – Dot version number, such as "18". |
| * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat". |
| */ |
| var version = { |
| full: '1.4.7', // all of these placeholder strings will be replaced by grunt's |
| major: 1, // package task |
| minor: 4, |
| dot: 7, |
| codeName: 'dark-luminescence' |
| }; |
| |
| |
| function publishExternalAPI(angular) { |
| extend(angular, { |
| 'bootstrap': bootstrap, |
| 'copy': copy, |
| 'extend': extend, |
| 'merge': merge, |
| 'equals': equals, |
| 'element': jqLite, |
| 'forEach': forEach, |
| 'injector': createInjector, |
| 'noop': noop, |
| 'bind': bind, |
| 'toJson': toJson, |
| 'fromJson': fromJson, |
| 'identity': identity, |
| 'isUndefined': isUndefined, |
| 'isDefined': isDefined, |
| 'isString': isString, |
| 'isFunction': isFunction, |
| 'isObject': isObject, |
| 'isNumber': isNumber, |
| 'isElement': isElement, |
| 'isArray': isArray, |
| 'version': version, |
| 'isDate': isDate, |
| 'lowercase': lowercase, |
| 'uppercase': uppercase, |
| 'callbacks': {counter: 0}, |
| 'getTestability': getTestability, |
| '$$minErr': minErr, |
| '$$csp': csp, |
| 'reloadWithDebugInfo': reloadWithDebugInfo |
| }); |
| |
| angularModule = setupModuleLoader(window); |
| |
| angularModule('ng', ['ngLocale'], ['$provide', |
| function ngModule($provide) { |
| // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it. |
| $provide.provider({ |
| $$sanitizeUri: $$SanitizeUriProvider |
| }); |
| $provide.provider('$compile', $CompileProvider). |
| directive({ |
| a: htmlAnchorDirective, |
| input: inputDirective, |
| textarea: inputDirective, |
| form: formDirective, |
| script: scriptDirective, |
| select: selectDirective, |
| style: styleDirective, |
| option: optionDirective, |
| ngBind: ngBindDirective, |
| ngBindHtml: ngBindHtmlDirective, |
| ngBindTemplate: ngBindTemplateDirective, |
| ngClass: ngClassDirective, |
| ngClassEven: ngClassEvenDirective, |
| ngClassOdd: ngClassOddDirective, |
| ngCloak: ngCloakDirective, |
| ngController: ngControllerDirective, |
| ngForm: ngFormDirective, |
| ngHide: ngHideDirective, |
| ngIf: ngIfDirective, |
| ngInclude: ngIncludeDirective, |
| ngInit: ngInitDirective, |
| ngNonBindable: ngNonBindableDirective, |
| ngPluralize: ngPluralizeDirective, |
| ngRepeat: ngRepeatDirective, |
| ngShow: ngShowDirective, |
| ngStyle: ngStyleDirective, |
| ngSwitch: ngSwitchDirective, |
| ngSwitchWhen: ngSwitchWhenDirective, |
| ngSwitchDefault: ngSwitchDefaultDirective, |
| ngOptions: ngOptionsDirective, |
| ngTransclude: ngTranscludeDirective, |
| ngModel: ngModelDirective, |
| ngList: ngListDirective, |
| ngChange: ngChangeDirective, |
| pattern: patternDirective, |
| ngPattern: patternDirective, |
| required: requiredDirective, |
| ngRequired: requiredDirective, |
| minlength: minlengthDirective, |
| ngMinlength: minlengthDirective, |
| maxlength: maxlengthDirective, |
| ngMaxlength: maxlengthDirective, |
| ngValue: ngValueDirective, |
| ngModelOptions: ngModelOptionsDirective |
| }). |
| directive({ |
| ngInclude: ngIncludeFillContentDirective |
| }). |
| directive(ngAttributeAliasDirectives). |
| directive(ngEventDirectives); |
| $provide.provider({ |
| $anchorScroll: $AnchorScrollProvider, |
| $animate: $AnimateProvider, |
| $animateCss: $CoreAnimateCssProvider, |
| $$animateQueue: $$CoreAnimateQueueProvider, |
| $$AnimateRunner: $$CoreAnimateRunnerProvider, |
| $browser: $BrowserProvider, |
| $cacheFactory: $CacheFactoryProvider, |
| $controller: $ControllerProvider, |
| $document: $DocumentProvider, |
| $exceptionHandler: $ExceptionHandlerProvider, |
| $filter: $FilterProvider, |
| $$forceReflow: $$ForceReflowProvider, |
| $interpolate: $InterpolateProvider, |
| $interval: $IntervalProvider, |
| $http: $HttpProvider, |
| $httpParamSerializer: $HttpParamSerializerProvider, |
| $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider, |
| $httpBackend: $HttpBackendProvider, |
| $xhrFactory: $xhrFactoryProvider, |
| $location: $LocationProvider, |
| $log: $LogProvider, |
| $parse: $ParseProvider, |
| $rootScope: $RootScopeProvider, |
| $q: $QProvider, |
| $$q: $$QProvider, |
| $sce: $SceProvider, |
| $sceDelegate: $SceDelegateProvider, |
| $sniffer: $SnifferProvider, |
| $templateCache: $TemplateCacheProvider, |
| $templateRequest: $TemplateRequestProvider, |
| $$testability: $$TestabilityProvider, |
| $timeout: $TimeoutProvider, |
| $window: $WindowProvider, |
| $$rAF: $$RAFProvider, |
| $$jqLite: $$jqLiteProvider, |
| $$HashMap: $$HashMapProvider, |
| $$cookieReader: $$CookieReaderProvider |
| }); |
| } |
| ]); |
| } |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Any commits to this file should be reviewed with security in mind. * |
| * Changes to this file can potentially create security vulnerabilities. * |
| * An approval from 2 Core members with history of modifying * |
| * this file is required. * |
| * * |
| * Does the change somehow allow for arbitrary javascript to be executed? * |
| * Or allows for someone to change the prototype of built-in objects? * |
| * Or gives undesired access to variables likes document or window? * |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* global JQLitePrototype: true, |
| addEventListenerFn: true, |
| removeEventListenerFn: true, |
| BOOLEAN_ATTR: true, |
| ALIASED_ATTR: true, |
| */ |
| |
| ////////////////////////////////// |
| //JQLite |
| ////////////////////////////////// |
| |
| /** |
| * @ngdoc function |
| * @name angular.element |
| * @module ng |
| * @kind function |
| * |
| * @description |
| * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element. |
| * |
| * If jQuery is available, `angular.element` is an alias for the |
| * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element` |
| * delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite." |
| * |
| * <div class="alert alert-success">jqLite is a tiny, API-compatible subset of jQuery that allows |
| * Angular to manipulate the DOM in a cross-browser compatible way. **jqLite** implements only the most |
| * commonly needed functionality with the goal of having a very small footprint.</div> |
| * |
| * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. |
| * |
| * <div class="alert">**Note:** all element references in Angular are always wrapped with jQuery or |
| * jqLite; they are never raw DOM references.</div> |
| * |
| * ## Angular's jqLite |
| * jqLite provides only the following jQuery methods: |
| * |
| * - [`addClass()`](http://api.jquery.com/addClass/) |
| * - [`after()`](http://api.jquery.com/after/) |
| * - [`append()`](http://api.jquery.com/append/) |
| * - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters |
| * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData |
| * - [`children()`](http://api.jquery.com/children/) - Does not support selectors |
| * - [`clone()`](http://api.jquery.com/clone/) |
| * - [`contents()`](http://api.jquery.com/contents/) |
| * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`. As a setter, does not convert numbers to strings or append 'px'. |
| * - [`data()`](http://api.jquery.com/data/) |
| * - [`detach()`](http://api.jquery.com/detach/) |
| * - [`empty()`](http://api.jquery.com/empty/) |
| * - [`eq()`](http://api.jquery.com/eq/) |
| * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name |
| * - [`hasClass()`](http://api.jquery.com/hasClass/) |
| * - [`html()`](http://api.jquery.com/html/) |
| * - [`next()`](http://api.jquery.com/next/) - Does not support selectors |
| * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData |
| * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces, selectors or event object as parameter |
| * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors |
| * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors |
| * - [`prepend()`](http://api.jquery.com/prepend/) |
| * - [`prop()`](http://api.jquery.com/prop/) |
| * - [`ready()`](http://api.jquery.com/ready/) |
| * - [`remove()`](http://api.jquery.com/remove/) |
| * - [`removeAttr()`](http://api.jquery.com/removeAttr/) |
| * - [`removeClass()`](http://api.jquery.com/removeClass/) |
| * - [`removeData()`](http://api.jquery.com/removeData/) |
| * - [`replaceWith()`](http://api.jquery.com/replaceWith/) |
| * - [`text()`](http://api.jquery.com/text/) |
| * - [`toggleClass()`](http://api.jquery.com/toggleClass/) |
| * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers. |
| * - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces or event object as parameter |
| * - [`val()`](http://api.jquery.com/val/) |
| * - [`wrap()`](http://api.jquery.com/wrap/) |
| * |
| * ## jQuery/jqLite Extras |
| * Angular also provides the following additional methods and events to both jQuery and jqLite: |
| * |
| * ### Events |
| * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event |
| * on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM |
| * element before it is removed. |
| * |
| * ### Methods |
| * - `controller(name)` - retrieves the controller of the current element or its parent. By default |
| * retrieves controller associated with the `ngController` directive. If `name` is provided as |
| * camelCase directive name, then the controller for this directive will be retrieved (e.g. |
| * `'ngModel'`). |
| * - `injector()` - retrieves the injector of the current element or its parent. |
| * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current |
| * element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to |
| * be enabled. |
| * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the |
| * current element. This getter should be used only on elements that contain a directive which starts a new isolate |
| * scope. Calling `scope()` on this element always returns the original non-isolate scope. |
| * Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled. |
| * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top |
| * parent element is reached. |
| * |
| * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery. |
| * @returns {Object} jQuery object. |
| */ |
| |
| JQLite.expando = 'ng339'; |
| |
| var jqCache = JQLite.cache = {}, |
| jqId = 1, |
| addEventListenerFn = function(element, type, fn) { |
| element.addEventListener(type, fn, false); |
| }, |
| removeEventListenerFn = function(element, type, fn) { |
| element.removeEventListener(type, fn, false); |
| }; |
| |
| /* |
| * !!! This is an undocumented "private" function !!! |
| */ |
| JQLite._data = function(node) { |
| //jQuery always returns an object on cache miss |
| return this.cache[node[this.expando]] || {}; |
| }; |
| |
| function jqNextId() { return ++jqId; } |
| |
| |
| var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g; |
| var MOZ_HACK_REGEXP = /^moz([A-Z])/; |
| var MOUSE_EVENT_MAP= { mouseleave: "mouseout", mouseenter: "mouseover"}; |
| var jqLiteMinErr = minErr('jqLite'); |
| |
| /** |
| * Converts snake_case to camelCase. |
| * Also there is special case for Moz prefix starting with upper case letter. |
| * @param name Name to normalize |
| */ |
| function camelCase(name) { |
| return name. |
| replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) { |
| return offset ? letter.toUpperCase() : letter; |
| }). |
| replace(MOZ_HACK_REGEXP, 'Moz$1'); |
| } |
| |
| var SINGLE_TAG_REGEXP = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/; |
| var HTML_REGEXP = /<|&#?\w+;/; |
| var TAG_NAME_REGEXP = /<([\w:-]+)/; |
| var XHTML_TAG_REGEXP = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi; |
| |
| var wrapMap = { |
| 'option': [1, '<select multiple="multiple">', '</select>'], |
| |
| 'thead': [1, '<table>', '</table>'], |
| 'col': [2, '<table><colgroup>', '</colgroup></table>'], |
| 'tr': [2, '<table><tbody>', '</tbody></table>'], |
| 'td': [3, '<table><tbody><tr>', '</tr></tbody></table>'], |
| '_default': [0, "", ""] |
| }; |
| |
| wrapMap.optgroup = wrapMap.option; |
| wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; |
| wrapMap.th = wrapMap.td; |
| |
| |
| function jqLiteIsTextNode(html) { |
| return !HTML_REGEXP.test(html); |
| } |
| |
| function jqLiteAcceptsData(node) { |
| // The window object can accept data but has no nodeType |
| // Otherwise we are only interested in elements (1) and documents (9) |
| var nodeType = node.nodeType; |
| return nodeType === NODE_TYPE_ELEMENT || !nodeType || nodeType === NODE_TYPE_DOCUMENT; |
| } |
| |
| function jqLiteHasData(node) { |
| for (var key in jqCache[node.ng339]) { |
| return true; |
| } |
| return false; |
| } |
| |
| function jqLiteBuildFragment(html, context) { |
| var tmp, tag, wrap, |
| fragment = context.createDocumentFragment(), |
| nodes = [], i; |
| |
| if (jqLiteIsTextNode(html)) { |
| // Convert non-html into a text node |
| nodes.push(context.createTextNode(html)); |
| } else { |
| // Convert html into DOM nodes |
| tmp = tmp || fragment.appendChild(context.createElement("div")); |
| tag = (TAG_NAME_REGEXP.exec(html) || ["", ""])[1].toLowerCase(); |
| wrap = wrapMap[tag] || wrapMap._default; |
| tmp.innerHTML = wrap[1] + html.replace(XHTML_TAG_REGEXP, "<$1></$2>") + wrap[2]; |
| |
| // Descend through wrappers to the right content |
| i = wrap[0]; |
| while (i--) { |
| tmp = tmp.lastChild; |
| } |
| |
| nodes = concat(nodes, tmp.childNodes); |
| |
| tmp = fragment.firstChild; |
| tmp.textContent = ""; |
| } |
| |
| // Remove wrapper from fragment |
| fragment.textContent = ""; |
| fragment.innerHTML = ""; // Clear inner HTML |
| forEach(nodes, function(node) { |
| fragment.appendChild(node); |
| }); |
| |
| return fragment; |
| } |
| |
| function jqLiteParseHTML(html, context) { |
| context = context || document; |
| var parsed; |
| |
| if ((parsed = SINGLE_TAG_REGEXP.exec(html))) { |
| return [context.createElement(parsed[1])]; |
| } |
| |
| if ((parsed = jqLiteBuildFragment(html, context))) { |
| return parsed.childNodes; |
| } |
| |
| return []; |
| } |
| |
| ///////////////////////////////////////////// |
| function JQLite(element) { |
| if (element instanceof JQLite) { |
| return element; |
| } |
| |
| var argIsString; |
| |
| if (isString(element)) { |
| element = trim(element); |
| argIsString = true; |
| } |
| if (!(this instanceof JQLite)) { |
| if (argIsString && element.charAt(0) != '<') { |
| throw jqLiteMinErr('nosel', 'Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element'); |
| } |
| return new JQLite(element); |
| } |
| |
| if (argIsString) { |
| jqLiteAddNodes(this, jqLiteParseHTML(element)); |
| } else { |
| jqLiteAddNodes(this, element); |
| } |
| } |
| |
| function jqLiteClone(element) { |
| return element.cloneNode(true); |
| } |
| |
| function jqLiteDealoc(element, onlyDescendants) { |
| if (!onlyDescendants) jqLiteRemoveData(element); |
| |
| if (element.querySelectorAll) { |
| var descendants = element.querySelectorAll('*'); |
| for (var i = 0, l = descendants.length; i < l; i++) { |
| jqLiteRemoveData(descendants[i]); |
| } |
| } |
| } |
| |
| function jqLiteOff(element, type, fn, unsupported) { |
| if (isDefined(unsupported)) throw jqLiteMinErr('offargs', 'jqLite#off() does not support the `selector` argument'); |
| |
| var expandoStore = jqLiteExpandoStore(element); |
| var events = expandoStore && expandoStore.events; |
| var handle = expandoStore && expandoStore.handle; |
| |
| if (!handle) return; //no listeners registered |
| |
| if (!type) { |
| for (type in events) { |
| if (type !== '$destroy') { |
| removeEventListenerFn(element, type, handle); |
| } |
| delete events[type]; |
| } |
| } else { |
| forEach(type.split(' '), function(type) { |
| if (isDefined(fn)) { |
| var listenerFns = events[type]; |
| arrayRemove(listenerFns || [], fn); |
| if (listenerFns && listenerFns.length > 0) { |
| return; |
| } |
| } |
| |
| removeEventListenerFn(element, type, handle); |
| delete events[type]; |
| }); |
| } |
| } |
| |
| function jqLiteRemoveData(element, name) { |
| var expandoId = element.ng339; |
| var expandoStore = expandoId && jqCache[expandoId]; |
| |
| if (expandoStore) { |
| if (name) { |
| delete expandoStore.data[name]; |
| return; |
| } |
| |
| if (expandoStore.handle) { |
| if (expandoStore.events.$destroy) { |
| expandoStore.handle({}, '$destroy'); |
| } |
| jqLiteOff(element); |
| } |
| delete jqCache[expandoId]; |
| element.ng339 = undefined; // don't delete DOM expandos. IE and Chrome don't like it |
| } |
| } |
| |
| |
| function jqLiteExpandoStore(element, createIfNecessary) { |
| var expandoId = element.ng339, |
| expandoStore = expandoId && jqCache[expandoId]; |
| |
| if (createIfNecessary && !expandoStore) { |
| element.ng339 = expandoId = jqNextId(); |
| expandoStore = jqCache[expandoId] = {events: {}, data: {}, handle: undefined}; |
| } |
| |
| return expandoStore; |
| } |
| |
| |
| function jqLiteData(element, key, value) { |
| if (jqLiteAcceptsData(element)) { |
| |
| var isSimpleSetter = isDefined(value); |
| var isSimpleGetter = !isSimpleSetter && key && !isObject(key); |
| var massGetter = !key; |
| var expandoStore = jqLiteExpandoStore(element, !isSimpleGetter); |
| var data = expandoStore && expandoStore.data; |
| |
| if (isSimpleSetter) { // data('key', value) |
| data[key] = value; |
| } else { |
| if (massGetter) { // data() |
| return data; |
| } else { |
| if (isSimpleGetter) { // data('key') |
| // don't force creation of expandoStore if it doesn't exist yet |
| return data && data[key]; |
| } else { // mass-setter: data({key1: val1, key2: val2}) |
| extend(data, key); |
| } |
| } |
| } |
| } |
| } |
| |
| function jqLiteHasClass(element, selector) { |
| if (!element.getAttribute) return false; |
| return ((" " + (element.getAttribute('class') || '') + " ").replace(/[\n\t]/g, " "). |
| indexOf(" " + selector + " ") > -1); |
| } |
| |
| function jqLiteRemoveClass(element, cssClasses) { |
| if (cssClasses && element.setAttribute) { |
| forEach(cssClasses.split(' '), function(cssClass) { |
| element.setAttribute('class', trim( |
| (" " + (element.getAttribute('class') || '') + " ") |
| .replace(/[\n\t]/g, " ") |
| .replace(" " + trim(cssClass) + " ", " ")) |
| ); |
| }); |
| } |
| } |
| |
| function jqLiteAddClass(element, cssClasses) { |
| if (cssClasses && element.setAttribute) { |
| var existingClasses = (' ' + (element.getAttribute('class') || '') + ' ') |
| .replace(/[\n\t]/g, " "); |
| |
| forEach(cssClasses.split(' '), function(cssClass) { |
| cssClass = trim(cssClass); |
| if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) { |
| existingClasses += cssClass + ' '; |
| } |
| }); |
| |
| element.setAttribute('class', trim(existingClasses)); |
| } |
| } |
| |
| |
| function jqLiteAddNodes(root, elements) { |
| // THIS CODE IS VERY HOT. Don't make changes without benchmarking. |
| |
| if (elements) { |
| |
| // if a Node (the most common case) |
| if (elements.nodeType) { |
| root[root.length++] = elements; |
| } else { |
| var length = elements.length; |
| |
| // if an Array or NodeList and not a Window |
| if (typeof length === 'number' && elements.window !== elements) { |
| if (length) { |
| for (var i = 0; i < length; i++) { |
| root[root.length++] = elements[i]; |
| } |
| } |
| } else { |
| root[root.length++] = elements; |
| } |
| } |
| } |
| } |
| |
| |
| function jqLiteController(element, name) { |
| return jqLiteInheritedData(element, '$' + (name || 'ngController') + 'Controller'); |
| } |
| |
| function jqLiteInheritedData(element, name, value) { |
| // if element is the document object work with the html element instead |
| // this makes $(document).scope() possible |
| if (element.nodeType == NODE_TYPE_DOCUMENT) { |
| element = element.documentElement; |
| } |
| var names = isArray(name) ? name : [name]; |
| |
| while (element) { |
| for (var i = 0, ii = names.length; i < ii; i++) { |
| if (isDefined(value = jqLite.data(element, names[i]))) return value; |
| } |
| |
| // If dealing with a document fragment node with a host element, and no parent, use the host |
| // element as the parent. This enables directives within a Shadow DOM or polyfilled Shadow DOM |
| // to lookup parent controllers. |
| element = element.parentNode || (element.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && element.host); |
| } |
| } |
| |
| function jqLiteEmpty(element) { |
| jqLiteDealoc(element, true); |
| while (element.firstChild) { |
| element.removeChild(element.firstChild); |
| } |
| } |
| |
| function jqLiteRemove(element, keepData) { |
| if (!keepData) jqLiteDealoc(element); |
| var parent = element.parentNode; |
| if (parent) parent.removeChild(element); |
| } |
| |
| |
| function jqLiteDocumentLoaded(action, win) { |
| win = win || window; |
| if (win.document.readyState === 'complete') { |
| // Force the action to be run async for consistent behaviour |
| // from the action's point of view |
| // i.e. it will definitely not be in a $apply |
| win.setTimeout(action); |
| } else { |
| // No need to unbind this handler as load is only ever called once |
| jqLite(win).on('load', action); |
| } |
| } |
| |
| ////////////////////////////////////////// |
| // Functions which are declared directly. |
| ////////////////////////////////////////// |
| var JQLitePrototype = JQLite.prototype = { |
| ready: function(fn) { |
| var fired = false; |
| |
| function trigger() { |
| if (fired) return; |
| fired = true; |
| fn(); |
| } |
| |
| // check if document is already loaded |
| if (document.readyState === 'complete') { |
| setTimeout(trigger); |
| } else { |
| this.on('DOMContentLoaded', trigger); // works for modern browsers and IE9 |
| // we can not use jqLite since we are not done loading and jQuery could be loaded later. |
| // jshint -W064 |
| JQLite(window).on('load', trigger); // fallback to window.onload for others |
| // jshint +W064 |
| } |
| }, |
| toString: function() { |
| var value = []; |
| forEach(this, function(e) { value.push('' + e);}); |
| return '[' + value.join(', ') + ']'; |
| }, |
| |
| eq: function(index) { |
| return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]); |
| }, |
| |
| length: 0, |
| push: push, |
| sort: [].sort, |
| splice: [].splice |
| }; |
| |
| ////////////////////////////////////////// |
| // Functions iterating getter/setters. |
| // these functions return self on setter and |
| // value on get. |
| ////////////////////////////////////////// |
| var BOOLEAN_ATTR = {}; |
| forEach('multiple,selected,checked,disabled,readOnly,required,open'.split(','), function(value) { |
| BOOLEAN_ATTR[lowercase(value)] = value; |
| }); |
| var BOOLEAN_ELEMENTS = {}; |
| forEach('input,select,option,textarea,button,form,details'.split(','), function(value) { |
| BOOLEAN_ELEMENTS[value] = true; |
| }); |
| var ALIASED_ATTR = { |
| 'ngMinlength': 'minlength', |
| 'ngMaxlength': 'maxlength', |
| 'ngMin': 'min', |
| 'ngMax': 'max', |
| 'ngPattern': 'pattern' |
| }; |
| |
| function getBooleanAttrName(element, name) { |
| // check dom last since we will most likely fail on name |
| var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()]; |
| |
| // booleanAttr is here twice to minimize DOM access |
| return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr; |
| } |
| |
| function getAliasedAttrName(name) { |
| return ALIASED_ATTR[name]; |
| } |
| |
| forEach({ |
| data: jqLiteData, |
| removeData: jqLiteRemoveData, |
| hasData: jqLiteHasData |
| }, function(fn, name) { |
| JQLite[name] = fn; |
| }); |
| |
| forEach({ |
| data: jqLiteData, |
| inheritedData: jqLiteInheritedData, |
| |
| scope: function(element) { |
| // Can't use jqLiteData here directly so we stay compatible with jQuery! |
| return jqLite.data(element, '$scope') || jqLiteInheritedData(element.parentNode || element, ['$isolateScope', '$scope']); |
| }, |
| |
| isolateScope: function(element) { |
| // Can't use jqLiteData here directly so we stay compatible with jQuery! |
| return jqLite.data(element, '$isolateScope') || jqLite.data(element, '$isolateScopeNoTemplate'); |
| }, |
| |
| controller: jqLiteController, |
| |
| injector: function(element) { |
| return jqLiteInheritedData(element, '$injector'); |
| }, |
| |
| removeAttr: function(element, name) { |
| element.removeAttribute(name); |
| }, |
| |
| hasClass: jqLiteHasClass, |
| |
| css: function(element, name, value) { |
| name = camelCase(name); |
| |
| if (isDefined(value)) { |
| element.style[name] = value; |
| } else { |
| return element.style[name]; |
| } |
| }, |
| |
| attr: function(element, name, value) { |
| var nodeType = element.nodeType; |
| if (nodeType === NODE_TYPE_TEXT || nodeType === NODE_TYPE_ATTRIBUTE || nodeType === NODE_TYPE_COMMENT) { |
| return; |
| } |
| var lowercasedName = lowercase(name); |
| if (BOOLEAN_ATTR[lowercasedName]) { |
| if (isDefined(value)) { |
| if (!!value) { |
| element[name] = true; |
| element.setAttribute(name, lowercasedName); |
| } else { |
| element[name] = false; |
| element.removeAttribute(lowercasedName); |
| } |
| } else { |
| return (element[name] || |
| (element.attributes.getNamedItem(name) || noop).specified) |
| ? lowercasedName |
| : undefined; |
| } |
| } else if (isDefined(value)) { |
| element.setAttribute(name, value); |
| } else if (element.getAttribute) { |
| // the extra argument "2" is to get the right thing for a.href in IE, see jQuery code |
| // some elements (e.g. Document) don't have get attribute, so return undefined |
| var ret = element.getAttribute(name, 2); |
| // normalize non-existing attributes to undefined (as jQuery) |
| return ret === null ? undefined : ret; |
| } |
| }, |
| |
| prop: function(element, name, value) { |
| if (isDefined(value)) { |
| element[name] = value; |
| } else { |
| return element[name]; |
| } |
| }, |
| |
| text: (function() { |
| getText.$dv = ''; |
| return getText; |
| |
| function getText(element, value) { |
| if (isUndefined(value)) { |
| var nodeType = element.nodeType; |
| return (nodeType === NODE_TYPE_ELEMENT || nodeType === NODE_TYPE_TEXT) ? element.textContent : ''; |
| } |
| element.textContent = value; |
| } |
| })(), |
| |
| val: function(element, value) { |
| if (isUndefined(value)) { |
| if (element.multiple && nodeName_(element) === 'select') { |
| var result = []; |
| forEach(element.options, function(option) { |
| if (option.selected) { |
| result.push(option.value || option.text); |
| } |
| }); |
| return result.length === 0 ? null : result; |
| } |
| return element.value; |
| } |
| element.value = value; |
| }, |
| |
| html: function(element, value) { |
| if (isUndefined(value)) { |
| return element.innerHTML; |
| } |
| jqLiteDealoc(element, true); |
| element.innerHTML = value; |
| }, |
| |
| empty: jqLiteEmpty |
| }, function(fn, name) { |
| /** |
| * Properties: writes return selection, reads return first value |
| */ |
| JQLite.prototype[name] = function(arg1, arg2) { |
| var i, key; |
| var nodeCount = this.length; |
| |
| // jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it |
| // in a way that survives minification. |
| // jqLiteEmpty takes no arguments but is a setter. |
| if (fn !== jqLiteEmpty && |
| (isUndefined((fn.length == 2 && (fn !== jqLiteHasClass && fn !== jqLiteController)) ? arg1 : arg2))) { |
| if (isObject(arg1)) { |
| |
| // we are a write, but the object properties are the key/values |
| for (i = 0; i < nodeCount; i++) { |
| if (fn === jqLiteData) { |
| // data() takes the whole object in jQuery |
| fn(this[i], arg1); |
| } else { |
| for (key in arg1) { |
| fn(this[i], key, arg1[key]); |
| } |
| } |
| } |
| // return self for chaining |
| return this; |
| } else { |
| // we are a read, so read the first child. |
| // TODO: do we still need this? |
| var value = fn.$dv; |
| // Only if we have $dv do we iterate over all, otherwise it is just the first element. |
| var jj = (isUndefined(value)) ? Math.min(nodeCount, 1) : nodeCount; |
| for (var j = 0; j < jj; j++) { |
| var nodeValue = fn(this[j], arg1, arg2); |
| value = value ? value + nodeValue : nodeValue; |
| } |
| return value; |
| } |
| } else { |
| // we are a write, so apply to all children |
| for (i = 0; i < nodeCount; i++) { |
| fn(this[i], arg1, arg2); |
| } |
| // return self for chaining |
| return this; |
| } |
| }; |
| }); |
| |
| function createEventHandler(element, events) { |
| var eventHandler = function(event, type) { |
| // jQuery specific api |
| event.isDefaultPrevented = function() { |
| return event.defaultPrevented; |
| }; |
| |
| var eventFns = events[type || event.type]; |
| var eventFnsLength = eventFns ? eventFns.length : 0; |
| |
| if (!eventFnsLength) return; |
| |
| if (isUndefined(event.immediatePropagationStopped)) { |
| var originalStopImmediatePropagation = event.stopImmediatePropagation; |
| event.stopImmediatePropagation = function() { |
| event.immediatePropagationStopped = true; |
| |
| if (event.stopPropagation) { |
| event.stopPropagation(); |
| } |
| |
| if (originalStopImmediatePropagation) { |
| originalStopImmediatePropagation.call(event); |
| } |
| }; |
| } |
| |
| event.isImmediatePropagationStopped = function() { |
| return event.immediatePropagationStopped === true; |
| }; |
| |
| // Copy event handlers in case event handlers array is modified during execution. |
| if ((eventFnsLength > 1)) { |
| eventFns = shallowCopy(eventFns); |
| } |
| |
| for (var i = 0; i < eventFnsLength; i++) { |
| if (!event.isImmediatePropagationStopped()) { |
| eventFns[i].call(element, event); |
| } |
| } |
| }; |
| |
| // TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all |
| // events on `element` |
| eventHandler.elem = element; |
| return eventHandler; |
| } |
| |
| ////////////////////////////////////////// |
| // Functions iterating traversal. |
| // These functions chain results into a single |
| // selector. |
| ////////////////////////////////////////// |
| forEach({ |
| removeData: jqLiteRemoveData, |
| |
| on: function jqLiteOn(element, type, fn, unsupported) { |
| if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters'); |
| |
| // Do not add event handlers to non-elements because they will not be cleaned up. |
| if (!jqLiteAcceptsData(element)) { |
| return; |
| } |
| |
| var expandoStore = jqLiteExpandoStore(element, true); |
| var events = expandoStore.events; |
| var handle = expandoStore.handle; |
| |
| if (!handle) { |
| handle = expandoStore.handle = createEventHandler(element, events); |
| } |
| |
| // http://jsperf.com/string-indexof-vs-split |
| var types = type.indexOf(' ') >= 0 ? type.split(' ') : [type]; |
| var i = types.length; |
| |
| while (i--) { |
| type = types[i]; |
| var eventFns = events[type]; |
| |
| if (!eventFns) { |
| events[type] = []; |
| |
| if (type === 'mouseenter' || type === 'mouseleave') { |
| // Refer to jQuery's implementation of mouseenter & mouseleave |
| // Read about mouseenter and mouseleave: |
| // http://www.quirksmode.org/js/events_mouse.html#link8 |
| |
| jqLiteOn(element, MOUSE_EVENT_MAP[type], function(event) { |
| var target = this, related = event.relatedTarget; |
| // For mousenter/leave call the handler if related is outside the target. |
| // NB: No relatedTarget if the mouse left/entered the browser window |
| if (!related || (related !== target && !target.contains(related))) { |
| handle(event, type); |
| } |
| }); |
| |
| } else { |
| if (type !== '$destroy') { |
| addEventListenerFn(element, type, handle); |
| } |
| } |
| eventFns = events[type]; |
| } |
| eventFns.push(fn); |
| } |
| }, |
| |
| off: jqLiteOff, |
| |
| one: function(element, type, fn) { |
| element = jqLite(element); |
| |
| //add the listener twice so that when it is called |
| //you can remove the original function and still be |
| //able to call element.off(ev, fn) normally |
| element.on(type, function onFn() { |
| element.off(type, fn); |
| element.off(type, onFn); |
| }); |
| element.on(type, fn); |
| }, |
| |
| replaceWith: function(element, replaceNode) { |
| var index, parent = element.parentNode; |
| jqLiteDealoc(element); |
| forEach(new JQLite(replaceNode), function(node) { |
| if (index) { |
| parent.insertBefore(node, index.nextSibling); |
| } else { |
| parent.replaceChild(node, element); |
| } |
| index = node; |
| }); |
| }, |
| |
| children: function(element) { |
| var children = []; |
| forEach(element.childNodes, function(element) { |
| if (element.nodeType === NODE_TYPE_ELEMENT) { |
| children.push(element); |
| } |
| }); |
| return children; |
| }, |
| |
| contents: function(element) { |
| return element.contentDocument || element.childNodes || []; |
| }, |
| |
| append: function(element, node) { |
| var nodeType = element.nodeType; |
| if (nodeType !== NODE_TYPE_ELEMENT && nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT) return; |
| |
| node = new JQLite(node); |
| |
| for (var i = 0, ii = node.length; i < ii; i++) { |
| var child = node[i]; |
| element.appendChild(child); |
| } |
| }, |
| |
| prepend: function(element, node) { |
| if (element.nodeType === NODE_TYPE_ELEMENT) { |
| var index = element.firstChild; |
| forEach(new JQLite(node), function(child) { |
| element.insertBefore(child, index); |
| }); |
| } |
| }, |
| |
| wrap: function(element, wrapNode) { |
| wrapNode = jqLite(wrapNode).eq(0).clone()[0]; |
| var parent = element.parentNode; |
| if (parent) { |
| parent.replaceChild(wrapNode, element); |
| } |
| wrapNode.appendChild(element); |
| }, |
| |
| remove: jqLiteRemove, |
| |
| detach: function(element) { |
| jqLiteRemove(element, true); |
| }, |
| |
| after: function(element, newElement) { |
| var index = element, parent = element.parentNode; |
| newElement = new JQLite(newElement); |
| |
| for (var i = 0, ii = newElement.length; i < ii; i++) { |
| var node = newElement[i]; |
| parent.insertBefore(node, index.nextSibling); |
| index = node; |
| } |
| }, |
| |
| addClass: jqLiteAddClass, |
| removeClass: jqLiteRemoveClass, |
| |
| toggleClass: function(element, selector, condition) { |
| if (selector) { |
| forEach(selector.split(' '), function(className) { |
| var classCondition = condition; |
| if (isUndefined(classCondition)) { |
| classCondition = !jqLiteHasClass(element, className); |
| } |
| (classCondition ? jqLiteAddClass : jqLiteRemoveClass)(element, className); |
| }); |
| } |
| }, |
| |
| parent: function(element) { |
| var parent = element.parentNode; |
| return parent && parent.nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT ? parent : null; |
| }, |
| |
| next: function(element) { |
| return element.nextElementSibling; |
| }, |
| |
| find: function(element, selector) { |
| if (element.getElementsByTagName) { |
| return element.getElementsByTagName(selector); |
| } else { |
| return []; |
| } |
| }, |
| |
| clone: jqLiteClone, |
| |
| triggerHandler: function(element, event, extraParameters) { |
| |
| var dummyEvent, eventFnsCopy, handlerArgs; |
| var eventName = event.type || event; |
| var expandoStore = jqLiteExpandoStore(element); |
| var events = expandoStore && expandoStore.events; |
| var eventFns = events && events[eventName]; |
| |
| if (eventFns) { |
| // Create a dummy event to pass to the handlers |
| dummyEvent = { |
| preventDefault: function() { this.defaultPrevented = true; }, |
| isDefaultPrevented: function() { return this.defaultPrevented === true; }, |
| stopImmediatePropagation: function() { this.immediatePropagationStopped = true; }, |
| isImmediatePropagationStopped: function() { return this.immediatePropagationStopped === true; }, |
| stopPropagation: noop, |
| type: eventName, |
| target: element |
| }; |
| |
| // If a custom event was provided then extend our dummy event with it |
| if (event.type) { |
| dummyEvent = extend(dummyEvent, event); |
| } |
| |
| // Copy event handlers in case event handlers array is modified during execution. |
| eventFnsCopy = shallowCopy(eventFns); |
| handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent]; |
| |
| forEach(eventFnsCopy, function(fn) { |
| if (!dummyEvent.isImmediatePropagationStopped()) { |
| fn.apply(element, handlerArgs); |
| } |
| }); |
| } |
| } |
| }, function(fn, name) { |
| /** |
| * chaining functions |
| */ |
| JQLite.prototype[name] = function(arg1, arg2, arg3) { |
| var value; |
| |
| for (var i = 0, ii = this.length; i < ii; i++) { |
| if (isUndefined(value)) { |
| value = fn(this[i], arg1, arg2, arg3); |
| if (isDefined(value)) { |
| // any function which returns a value needs to be wrapped |
| value = jqLite(value); |
| } |
| } else { |
| jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3)); |
| } |
| } |
| return isDefined(value) ? value : this; |
| }; |
| |
| // bind legacy bind/unbind to on/off |
| JQLite.prototype.bind = JQLite.prototype.on; |
| JQLite.prototype.unbind = JQLite.prototype.off; |
| }); |
| |
| |
| // Provider for private $$jqLite service |
| function $$jqLiteProvider() { |
| this.$get = function $$jqLite() { |
| return extend(JQLite, { |
| hasClass: function(node, classes) { |
| if (node.attr) node = node[0]; |
| return jqLiteHasClass(node, classes); |
| }, |
| addClass: function(node, classes) { |
| if (node.attr) node = node[0]; |
| return jqLiteAddClass(node, classes); |
| }, |
| removeClass: function(node, classes) { |
| if (node.attr) node = node[0]; |
| return jqLiteRemoveClass(node, classes); |
| } |
| }); |
| }; |
| } |
| |
| /** |
| * Computes a hash of an 'obj'. |
| * Hash of a: |
| * string is string |
| * number is number as string |
| * object is either result of calling $$hashKey function on the object or uniquely generated id, |
| * that is also assigned to the $$hashKey property of the object. |
| * |
| * @param obj |
| * @returns {string} hash string such that the same input will have the same hash string. |
| * The resulting string key is in 'type:hashKey' format. |
| */ |
| function hashKey(obj, nextUidFn) { |
| var key = obj && obj.$$hashKey; |
| |
| if (key) { |
| if (typeof key === 'function') { |
| key = obj.$$hashKey(); |
| } |
| return key; |
| } |
| |
| var objType = typeof obj; |
| if (objType == 'function' || (objType == 'object' && obj !== null)) { |
| key = obj.$$hashKey = objType + ':' + (nextUidFn || nextUid)(); |
| } else { |
| key = objType + ':' + obj; |
| } |
| |
| return key; |
| } |
| |
| /** |
| * HashMap which can use objects as keys |
| */ |
| function HashMap(array, isolatedUid) { |
| if (isolatedUid) { |
| var uid = 0; |
| this.nextUid = function() { |
| return ++uid; |
| }; |
| } |
| forEach(array, this.put, this); |
| } |
| HashMap.prototype = { |
| /** |
| * Store key value pair |
| * @param key key to store can be any type |
| * @param value value to store can be any type |
| */ |
| put: function(key, value) { |
| this[hashKey(key, this.nextUid)] = value; |
| }, |
| |
| /** |
| * @param key |
| * @returns {Object} the value for the key |
| */ |
| get: function(key) { |
| return this[hashKey(key, this.nextUid)]; |
| }, |
| |
| /** |
| * Remove the key/value pair |
| * @param key |
| */ |
| remove: function(key) { |
| var value = this[key = hashKey(key, this.nextUid)]; |
| delete this[key]; |
| return value; |
| } |
| }; |
| |
| var $$HashMapProvider = [function() { |
| this.$get = [function() { |
| return HashMap; |
| }]; |
| }]; |
| |
| /** |
| * @ngdoc function |
| * @module ng |
| * @name angular.injector |
| * @kind function |
| * |
| * @description |
| * Creates an injector object that can be used for retrieving services as well as for |
| * dependency injection (see {@link guide/di dependency injection}). |
| * |
| * @param {Array.<string|Function>} modules A list of module functions or their aliases. See |
| * {@link angular.module}. The `ng` module must be explicitly added. |
| * @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which |
| * disallows argument name annotation inference. |
| * @returns {injector} Injector object. See {@link auto.$injector $injector}. |
| * |
| * @example |
| * Typical usage |
| * ```js |
| * // create an injector |
| * var $injector = angular.injector(['ng']); |
| * |
| * // use the injector to kick off your application |
| * // use the type inference to auto inject arguments, or use implicit injection |
| * $injector.invoke(function($rootScope, $compile, $document) { |
| * $compile($document)($rootScope); |
| * $rootScope.$digest(); |
| * }); |
| * ``` |
| * |
| * Sometimes you want to get access to the injector of a currently running Angular app |
| * from outside Angular. Perhaps, you want to inject and compile some markup after the |
| * application has been bootstrapped. You can do this using the extra `injector()` added |
| * to JQuery/jqLite elements. See {@link angular.element}. |
| * |
| * *This is fairly rare but could be the case if a third party library is injecting the |
| * markup.* |
| * |
| * In the following example a new block of HTML containing a `ng-controller` |
| * directive is added to the end of the document body by JQuery. We then compile and link |
| * it into the current AngularJS scope. |
| * |
| * ```js |
| * var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>'); |
| * $(document.body).append($div); |
| * |
| * angular.element(document).injector().invoke(function($compile) { |
| * var scope = angular.element($div).scope(); |
| * $compile($div)(scope); |
| * }); |
| * ``` |
| */ |
| |
| |
| /** |
| * @ngdoc module |
| * @name auto |
| * @description |
| * |
| * Implicit module which gets automatically added to each {@link auto.$injector $injector}. |
| */ |
| |
| var FN_ARGS = /^[^\(]*\(\s*([^\)]*)\)/m; |
| var FN_ARG_SPLIT = /,/; |
| var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/; |
| var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg; |
| var $injectorMinErr = minErr('$injector'); |
| |
| function anonFn(fn) { |
| // For anonymous functions, showing at the very least the function signature can help in |
| // debugging. |
| var fnText = fn.toString().replace(STRIP_COMMENTS, ''), |
| args = fnText.match(FN_ARGS); |
| if (args) { |
| return 'function(' + (args[1] || '').replace(/[\s\r\n]+/, ' ') + ')'; |
| } |
| return 'fn'; |
| } |
| |
| function annotate(fn, strictDi, name) { |
| var $inject, |
| fnText, |
| argDecl, |
| last; |
| |
| if (typeof fn === 'function') { |
| if (!($inject = fn.$inject)) { |
| $inject = []; |
| if (fn.length) { |
| if (strictDi) { |
| if (!isString(name) || !name) { |
| name = fn.name || anonFn(fn); |
| } |
| throw $injectorMinErr('strictdi', |
| '{0} is not using explicit annotation and cannot be invoked in strict mode', name); |
| } |
| fnText = fn.toString().replace(STRIP_COMMENTS, ''); |
| argDecl = fnText.match(FN_ARGS); |
| forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg) { |
| arg.replace(FN_ARG, function(all, underscore, name) { |
| $inject.push(name); |
| }); |
| }); |
| } |
| fn.$inject = $inject; |
| } |
| } else if (isArray(fn)) { |
| last = fn.length - 1; |
| assertArgFn(fn[last], 'fn'); |
| $inject = fn.slice(0, last); |
| } else { |
| assertArgFn(fn, 'fn', true); |
| } |
| return $inject; |
| } |
| |
| /////////////////////////////////////// |
| |
| /** |
| * @ngdoc service |
| * @name $injector |
| * |
| * @description |
| * |
| * `$injector` is used to retrieve object instances as defined by |
| * {@link auto.$provide provider}, instantiate types, invoke methods, |
| * and load modules. |
| * |
| * The following always holds true: |
| * |
| * ```js |
| * var $injector = angular.injector(); |
| * expect($injector.get('$injector')).toBe($injector); |
| * expect($injector.invoke(function($injector) { |
| * return $injector; |
| * })).toBe($injector); |
| * ``` |
| * |
| * # Injection Function Annotation |
| * |
| * JavaScript does not have annotations, and annotations are needed for dependency injection. The |
| * following are all valid ways of annotating function with injection arguments and are equivalent. |
| * |
| * ```js |
| * // inferred (only works if code not minified/obfuscated) |
| * $injector.invoke(function(serviceA){}); |
| * |
| * // annotated |
| * function explicit(serviceA) {}; |
| * explicit.$inject = ['serviceA']; |
| * $injector.invoke(explicit); |
| * |
| * // inline |
| * $injector.invoke(['serviceA', function(serviceA){}]); |
| * ``` |
| * |
| * ## Inference |
| * |
| * In JavaScript calling `toString()` on a function returns the function definition. The definition |
| * can then be parsed and the function arguments can be extracted. This method of discovering |
| * annotations is disallowed when the injector is in strict mode. |
| * *NOTE:* This does not work with minification, and obfuscation tools since these tools change the |
| * argument names. |
| * |
| * ## `$inject` Annotation |
| * By adding an `$inject` property onto a function the injection parameters can be specified. |
| * |
| * ## Inline |
| * As an array of injection names, where the last item in the array is the function to call. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $injector#get |
| * |
| * @description |
| * Return an instance of the service. |
| * |
| * @param {string} name The name of the instance to retrieve. |
| * @param {string=} caller An optional string to provide the origin of the function call for error messages. |
| * @return {*} The instance. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $injector#invoke |
| * |
| * @description |
| * Invoke the method and supply the method arguments from the `$injector`. |
| * |
| * @param {Function|Array.<string|Function>} fn The injectable function to invoke. Function parameters are |
| * injected according to the {@link guide/di $inject Annotation} rules. |
| * @param {Object=} self The `this` for the invoked method. |
| * @param {Object=} locals Optional object. If preset then any argument names are read from this |
| * object first, before the `$injector` is consulted. |
| * @returns {*} the value returned by the invoked `fn` function. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $injector#has |
| * |
| * @description |
| * Allows the user to query if the particular service exists. |
| * |
| * @param {string} name Name of the service to query. |
| * @returns {boolean} `true` if injector has given service. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $injector#instantiate |
| * @description |
| * Create a new instance of JS type. The method takes a constructor function, invokes the new |
| * operator, and supplies all of the arguments to the constructor function as specified by the |
| * constructor annotation. |
| * |
| * @param {Function} Type Annotated constructor function. |
| * @param {Object=} locals Optional object. If preset then any argument names are read from this |
| * object first, before the `$injector` is consulted. |
| * @returns {Object} new instance of `Type`. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $injector#annotate |
| * |
| * @description |
| * Returns an array of service names which the function is requesting for injection. This API is |
| * used by the injector to determine which services need to be injected into the function when the |
| * function is invoked. There are three ways in which the function can be annotated with the needed |
| * dependencies. |
| * |
| * # Argument names |
| * |
| * The simplest form is to extract the dependencies from the arguments of the function. This is done |
| * by converting the function into a string using `toString()` method and extracting the argument |
| * names. |
| * ```js |
| * // Given |
| * function MyController($scope, $route) { |
| * // ... |
| * } |
| * |
| * // Then |
| * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']); |
| * ``` |
| * |
| * You can disallow this method by using strict injection mode. |
| * |
| * This method does not work with code minification / obfuscation. For this reason the following |
| * annotation strategies are supported. |
| * |
| * # The `$inject` property |
| * |
| * If a function has an `$inject` property and its value is an array of strings, then the strings |
| * represent names of services to be injected into the function. |
| * ```js |
| * // Given |
| * var MyController = function(obfuscatedScope, obfuscatedRoute) { |
| * // ... |
| * } |
| * // Define function dependencies |
| * MyController['$inject'] = ['$scope', '$route']; |
| * |
| * // Then |
| * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']); |
| * ``` |
| * |
| * # The array notation |
| * |
| * It is often desirable to inline Injected functions and that's when setting the `$inject` property |
| * is very inconvenient. In these situations using the array notation to specify the dependencies in |
| * a way that survives minification is a better choice: |
| * |
| * ```js |
| * // We wish to write this (not minification / obfuscation safe) |
| * injector.invoke(function($compile, $rootScope) { |
| * // ... |
| * }); |
| * |
| * // We are forced to write break inlining |
| * var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) { |
| * // ... |
| * }; |
| * tmpFn.$inject = ['$compile', '$rootScope']; |
| * injector.invoke(tmpFn); |
| * |
| * // To better support inline function the inline annotation is supported |
| * injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) { |
| * // ... |
| * }]); |
| * |
| * // Therefore |
| * expect(injector.annotate( |
| * ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}]) |
| * ).toEqual(['$compile', '$rootScope']); |
| * ``` |
| * |
| * @param {Function|Array.<string|Function>} fn Function for which dependent service names need to |
| * be retrieved as described above. |
| * |
| * @param {boolean=} [strictDi=false] Disallow argument name annotation inference. |
| * |
| * @returns {Array.<string>} The names of the services which the function requires. |
| */ |
| |
| |
| |
| |
| /** |
| * @ngdoc service |
| * @name $provide |
| * |
| * @description |
| * |
| * The {@link auto.$provide $provide} service has a number of methods for registering components |
| * with the {@link auto.$injector $injector}. Many of these functions are also exposed on |
| * {@link angular.Module}. |
| * |
| * An Angular **service** is a singleton object created by a **service factory**. These **service |
| * factories** are functions which, in turn, are created by a **service provider**. |
| * The **service providers** are constructor functions. When instantiated they must contain a |
| * property called `$get`, which holds the **service factory** function. |
| * |
| * When you request a service, the {@link auto.$injector $injector} is responsible for finding the |
| * correct **service provider**, instantiating it and then calling its `$get` **service factory** |
| * function to get the instance of the **service**. |
| * |
| * Often services have no configuration options and there is no need to add methods to the service |
| * provider. The provider will be no more than a constructor function with a `$get` property. For |
| * these cases the {@link auto.$provide $provide} service has additional helper methods to register |
| * services without specifying a provider. |
| * |
| * * {@link auto.$provide#provider provider(provider)} - registers a **service provider** with the |
| * {@link auto.$injector $injector} |
| * * {@link auto.$provide#constant constant(obj)} - registers a value/object that can be accessed by |
| * providers and services. |
| * * {@link auto.$provide#value value(obj)} - registers a value/object that can only be accessed by |
| * services, not providers. |
| * * {@link auto.$provide#factory factory(fn)} - registers a service **factory function**, `fn`, |
| * that will be wrapped in a **service provider** object, whose `$get` property will contain the |
| * given factory function. |
| * * {@link auto.$provide#service service(class)} - registers a **constructor function**, `class` |
| * that will be wrapped in a **service provider** object, whose `$get` property will instantiate |
| * a new object using the given constructor function. |
| * |
| * See the individual methods for more information and examples. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $provide#provider |
| * @description |
| * |
| * Register a **provider function** with the {@link auto.$injector $injector}. Provider functions |
| * are constructor functions, whose instances are responsible for "providing" a factory for a |
| * service. |
| * |
| * Service provider names start with the name of the service they provide followed by `Provider`. |
| * For example, the {@link ng.$log $log} service has a provider called |
| * {@link ng.$logProvider $logProvider}. |
| * |
| * Service provider objects can have additional methods which allow configuration of the provider |
| * and its service. Importantly, you can configure what kind of service is created by the `$get` |
| * method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a |
| * method {@link ng.$logProvider#debugEnabled debugEnabled} |
| * which lets you specify whether the {@link ng.$log $log} service will log debug messages to the |
| * console or not. |
| * |
| * @param {string} name The name of the instance. NOTE: the provider will be available under `name + |
| 'Provider'` key. |
| * @param {(Object|function())} provider If the provider is: |
| * |
| * - `Object`: then it should have a `$get` method. The `$get` method will be invoked using |
| * {@link auto.$injector#invoke $injector.invoke()} when an instance needs to be created. |
| * - `Constructor`: a new instance of the provider will be created using |
| * {@link auto.$injector#instantiate $injector.instantiate()}, then treated as `object`. |
| * |
| * @returns {Object} registered provider instance |
| |
| * @example |
| * |
| * The following example shows how to create a simple event tracking service and register it using |
| * {@link auto.$provide#provider $provide.provider()}. |
| * |
| * ```js |
| * // Define the eventTracker provider |
| * function EventTrackerProvider() { |
| * var trackingUrl = '/track'; |
| * |
| * // A provider method for configuring where the tracked events should been saved |
| * this.setTrackingUrl = function(url) { |
| * trackingUrl = url; |
| * }; |
| * |
| * // The service factory function |
| * this.$get = ['$http', function($http) { |
| * var trackedEvents = {}; |
| * return { |
| * // Call this to track an event |
| * event: function(event) { |
| * var count = trackedEvents[event] || 0; |
| * count += 1; |
| * trackedEvents[event] = count; |
| * return count; |
| * }, |
| * // Call this to save the tracked events to the trackingUrl |
| * save: function() { |
| * $http.post(trackingUrl, trackedEvents); |
| * } |
| * }; |
| * }]; |
| * } |
| * |
| * describe('eventTracker', function() { |
| * var postSpy; |
| * |
| * beforeEach(module(function($provide) { |
| * // Register the eventTracker provider |
| * $provide.provider('eventTracker', EventTrackerProvider); |
| * })); |
| * |
| * beforeEach(module(function(eventTrackerProvider) { |
| * // Configure eventTracker provider |
| * eventTrackerProvider.setTrackingUrl('/custom-track'); |
| * })); |
| * |
| * it('tracks events', inject(function(eventTracker) { |
| * expect(eventTracker.event('login')).toEqual(1); |
| * expect(eventTracker.event('login')).toEqual(2); |
| * })); |
| * |
| * it('saves to the tracking url', inject(function(eventTracker, $http) { |
| * postSpy = spyOn($http, 'post'); |
| * eventTracker.event('login'); |
| * eventTracker.save(); |
| * expect(postSpy).toHaveBeenCalled(); |
| * expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track'); |
| * expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track'); |
| * expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 }); |
| * })); |
| * }); |
| * ``` |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $provide#factory |
| * @description |
| * |
| * Register a **service factory**, which will be called to return the service instance. |
| * This is short for registering a service where its provider consists of only a `$get` property, |
| * which is the given service factory function. |
| * You should use {@link auto.$provide#factory $provide.factory(getFn)} if you do not need to |
| * configure your service in a provider. |
| * |
| * @param {string} name The name of the instance. |
| * @param {Function|Array.<string|Function>} $getFn The injectable $getFn for the instance creation. |
| * Internally this is a short hand for `$provide.provider(name, {$get: $getFn})`. |
| * @returns {Object} registered provider instance |
| * |
| * @example |
| * Here is an example of registering a service |
| * ```js |
| * $provide.factory('ping', ['$http', function($http) { |
| * return function ping() { |
| * return $http.send('/ping'); |
| * }; |
| * }]); |
| * ``` |
| * You would then inject and use this service like this: |
| * ```js |
| * someModule.controller('Ctrl', ['ping', function(ping) { |
| * ping(); |
| * }]); |
| * ``` |
| */ |
| |
| |
| /** |
| * @ngdoc method |
| * @name $provide#service |
| * @description |
| * |
| * Register a **service constructor**, which will be invoked with `new` to create the service |
| * instance. |
| * This is short for registering a service where its provider's `$get` property is the service |
| * constructor function that will be used to instantiate the service instance. |
| * |
| * You should use {@link auto.$provide#service $provide.service(class)} if you define your service |
| * as a type/class. |
| * |
| * @param {string} name The name of the instance. |
| * @param {Function|Array.<string|Function>} constructor An injectable class (constructor function) |
| * that will be instantiated. |
| * @returns {Object} registered provider instance |
| * |
| * @example |
| * Here is an example of registering a service using |
| * {@link auto.$provide#service $provide.service(class)}. |
| * ```js |
| * var Ping = function($http) { |
| * this.$http = $http; |
| * }; |
| * |
| * Ping.$inject = ['$http']; |
| * |
| * Ping.prototype.send = function() { |
| * return this.$http.get('/ping'); |
| * }; |
| * $provide.service('ping', Ping); |
| * ``` |
| * You would then inject and use this service like this: |
| * ```js |
| * someModule.controller('Ctrl', ['ping', function(ping) { |
| * ping.send(); |
| * }]); |
| * ``` |
| */ |
| |
| |
| /** |
| * @ngdoc method |
| * @name $provide#value |
| * @description |
| * |
| * Register a **value service** with the {@link auto.$injector $injector}, such as a string, a |
| * number, an array, an object or a function. This is short for registering a service where its |
| * provider's `$get` property is a factory function that takes no arguments and returns the **value |
| * service**. |
| * |
| * Value services are similar to constant services, except that they cannot be injected into a |
| * module configuration function (see {@link angular.Module#config}) but they can be overridden by |
| * an Angular |
| * {@link auto.$provide#decorator decorator}. |
| * |
| * @param {string} name The name of the instance. |
| * @param {*} value The value. |
| * @returns {Object} registered provider instance |
| * |
| * @example |
| * Here are some examples of creating value services. |
| * ```js |
| * $provide.value('ADMIN_USER', 'admin'); |
| * |
| * $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 }); |
| * |
| * $provide.value('halfOf', function(value) { |
| * return value / 2; |
| * }); |
| * ``` |
| */ |
| |
| |
| /** |
| * @ngdoc method |
| * @name $provide#constant |
| * @description |
| * |
| * Register a **constant service**, such as a string, a number, an array, an object or a function, |
| * with the {@link auto.$injector $injector}. Unlike {@link auto.$provide#value value} it can be |
| * injected into a module configuration function (see {@link angular.Module#config}) and it cannot |
| * be overridden by an Angular {@link auto.$provide#decorator decorator}. |
| * |
| * @param {string} name The name of the constant. |
| * @param {*} value The constant value. |
| * @returns {Object} registered instance |
| * |
| * @example |
| * Here a some examples of creating constants: |
| * ```js |
| * $provide.constant('SHARD_HEIGHT', 306); |
| * |
| * $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']); |
| * |
| * $provide.constant('double', function(value) { |
| * return value * 2; |
| * }); |
| * ``` |
| */ |
| |
| |
| /** |
| * @ngdoc method |
| * @name $provide#decorator |
| * @description |
| * |
| * Register a **service decorator** with the {@link auto.$injector $injector}. A service decorator |
| * intercepts the creation of a service, allowing it to override or modify the behaviour of the |
| * service. The object returned by the decorator may be the original service, or a new service |
| * object which replaces or wraps and delegates to the original service. |
| * |
| * @param {string} name The name of the service to decorate. |
| * @param {Function|Array.<string|Function>} decorator This function will be invoked when the service needs to be |
| * instantiated and should return the decorated service instance. The function is called using |
| * the {@link auto.$injector#invoke injector.invoke} method and is therefore fully injectable. |
| * Local injection arguments: |
| * |
| * * `$delegate` - The original service instance, which can be monkey patched, configured, |
| * decorated or delegated to. |
| * |
| * @example |
| * Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting |
| * calls to {@link ng.$log#error $log.warn()}. |
| * ```js |
| * $provide.decorator('$log', ['$delegate', function($delegate) { |
| * $delegate.warn = $delegate.error; |
| * return $delegate; |
| * }]); |
| * ``` |
| */ |
| |
| |
| function createInjector(modulesToLoad, strictDi) { |
| strictDi = (strictDi === true); |
| var INSTANTIATING = {}, |
| providerSuffix = 'Provider', |
| path = [], |
| loadedModules = new HashMap([], true), |
| providerCache = { |
| $provide: { |
| provider: supportObject(provider), |
| factory: supportObject(factory), |
| service: supportObject(service), |
| value: supportObject(value), |
| constant: supportObject(constant), |
| decorator: decorator |
| } |
| }, |
| providerInjector = (providerCache.$injector = |
| createInternalInjector(providerCache, function(serviceName, caller) { |
| if (angular.isString(caller)) { |
| path.push(caller); |
| } |
| throw $injectorMinErr('unpr', "Unknown provider: {0}", path.join(' <- ')); |
| })), |
| instanceCache = {}, |
| instanceInjector = (instanceCache.$injector = |
| createInternalInjector(instanceCache, function(serviceName, caller) { |
| var provider = providerInjector.get(serviceName + providerSuffix, caller); |
| return instanceInjector.invoke(provider.$get, provider, undefined, serviceName); |
| })); |
| |
| |
| forEach(loadModules(modulesToLoad), function(fn) { if (fn) instanceInjector.invoke(fn); }); |
| |
| return instanceInjector; |
| |
| //////////////////////////////////// |
| // $provider |
| //////////////////////////////////// |
| |
| function supportObject(delegate) { |
| return function(key, value) { |
| if (isObject(key)) { |
| forEach(key, reverseParams(delegate)); |
| } else { |
| return delegate(key, value); |
| } |
| }; |
| } |
| |
| function provider(name, provider_) { |
| assertNotHasOwnProperty(name, 'service'); |
| if (isFunction(provider_) || isArray(provider_)) { |
| provider_ = providerInjector.instantiate(provider_); |
| } |
| if (!provider_.$get) { |
| throw $injectorMinErr('pget', "Provider '{0}' must define $get factory method.", name); |
| } |
| return providerCache[name + providerSuffix] = provider_; |
| } |
| |
| function enforceReturnValue(name, factory) { |
| return function enforcedReturnValue() { |
| var result = instanceInjector.invoke(factory, this); |
| if (isUndefined(result)) { |
| throw $injectorMinErr('undef', "Provider '{0}' must return a value from $get factory method.", name); |
| } |
| return result; |
| }; |
| } |
| |
| function factory(name, factoryFn, enforce) { |
| return provider(name, { |
| $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn |
| }); |
| } |
| |
| function service(name, constructor) { |
| return factory(name, ['$injector', function($injector) { |
| return $injector.instantiate(constructor); |
| }]); |
| } |
| |
| function value(name, val) { return factory(name, valueFn(val), false); } |
| |
| function constant(name, value) { |
| assertNotHasOwnProperty(name, 'constant'); |
| providerCache[name] = value; |
| instanceCache[name] = value; |
| } |
| |
| function decorator(serviceName, decorFn) { |
| var origProvider = providerInjector.get(serviceName + providerSuffix), |
| orig$get = origProvider.$get; |
| |
| origProvider.$get = function() { |
| var origInstance = instanceInjector.invoke(orig$get, origProvider); |
| return instanceInjector.invoke(decorFn, null, {$delegate: origInstance}); |
| }; |
| } |
| |
| //////////////////////////////////// |
| // Module Loading |
| //////////////////////////////////// |
| function loadModules(modulesToLoad) { |
| assertArg(isUndefined(modulesToLoad) || isArray(modulesToLoad), 'modulesToLoad', 'not an array'); |
| var runBlocks = [], moduleFn; |
| forEach(modulesToLoad, function(module) { |
| if (loadedModules.get(module)) return; |
| loadedModules.put(module, true); |
| |
| function runInvokeQueue(queue) { |
| var i, ii; |
| for (i = 0, ii = queue.length; i < ii; i++) { |
| var invokeArgs = queue[i], |
| provider = providerInjector.get(invokeArgs[0]); |
| |
| provider[invokeArgs[1]].apply(provider, invokeArgs[2]); |
| } |
| } |
| |
| try { |
| if (isString(module)) { |
| moduleFn = angularModule(module); |
| runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks); |
| runInvokeQueue(moduleFn._invokeQueue); |
| runInvokeQueue(moduleFn._configBlocks); |
| } else if (isFunction(module)) { |
| runBlocks.push(providerInjector.invoke(module)); |
| } else if (isArray(module)) { |
| runBlocks.push(providerInjector.invoke(module)); |
| } else { |
| assertArgFn(module, 'module'); |
| } |
| } catch (e) { |
| if (isArray(module)) { |
| module = module[module.length - 1]; |
| } |
| if (e.message && e.stack && e.stack.indexOf(e.message) == -1) { |
| // Safari & FF's stack traces don't contain error.message content |
| // unlike those of Chrome and IE |
| // So if stack doesn't contain message, we create a new string that contains both. |
| // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here. |
| /* jshint -W022 */ |
| e = e.message + '\n' + e.stack; |
| } |
| throw $injectorMinErr('modulerr', "Failed to instantiate module {0} due to:\n{1}", |
| module, e.stack || e.message || e); |
| } |
| }); |
| return runBlocks; |
| } |
| |
| //////////////////////////////////// |
| // internal Injector |
| //////////////////////////////////// |
| |
| function createInternalInjector(cache, factory) { |
| |
| function getService(serviceName, caller) { |
| if (cache.hasOwnProperty(serviceName)) { |
| if (cache[serviceName] === INSTANTIATING) { |
| throw $injectorMinErr('cdep', 'Circular dependency found: {0}', |
| serviceName + ' <- ' + path.join(' <- ')); |
| } |
| return cache[serviceName]; |
| } else { |
| try { |
| path.unshift(serviceName); |
| cache[serviceName] = INSTANTIATING; |
| return cache[serviceName] = factory(serviceName, caller); |
| } catch (err) { |
| if (cache[serviceName] === INSTANTIATING) { |
| delete cache[serviceName]; |
| } |
| throw err; |
| } finally { |
| path.shift(); |
| } |
| } |
| } |
| |
| function invoke(fn, self, locals, serviceName) { |
| if (typeof locals === 'string') { |
| serviceName = locals; |
| locals = null; |
| } |
| |
| var args = [], |
| $inject = createInjector.$$annotate(fn, strictDi, serviceName), |
| length, i, |
| key; |
| |
| for (i = 0, length = $inject.length; i < length; i++) { |
| key = $inject[i]; |
| if (typeof key !== 'string') { |
| throw $injectorMinErr('itkn', |
| 'Incorrect injection token! Expected service name as string, got {0}', key); |
| } |
| args.push( |
| locals && locals.hasOwnProperty(key) |
| ? locals[key] |
| : getService(key, serviceName) |
| ); |
| } |
| if (isArray(fn)) { |
| fn = fn[length]; |
| } |
| |
| // http://jsperf.com/angularjs-invoke-apply-vs-switch |
| // #5388 |
| return fn.apply(self, args); |
| } |
| |
| function instantiate(Type, locals, serviceName) { |
| // Check if Type is annotated and use just the given function at n-1 as parameter |
| // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]); |
| // Object creation: http://jsperf.com/create-constructor/2 |
| var instance = Object.create((isArray(Type) ? Type[Type.length - 1] : Type).prototype || null); |
| var returnedValue = invoke(Type, instance, locals, serviceName); |
| |
| return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance; |
| } |
| |
| return { |
| invoke: invoke, |
| instantiate: instantiate, |
| get: getService, |
| annotate: createInjector.$$annotate, |
| has: function(name) { |
| return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name); |
| } |
| }; |
| } |
| } |
| |
| createInjector.$$annotate = annotate; |
| |
| /** |
| * @ngdoc provider |
| * @name $anchorScrollProvider |
| * |
| * @description |
| * Use `$anchorScrollProvider` to disable automatic scrolling whenever |
| * {@link ng.$location#hash $location.hash()} changes. |
| */ |
| function $AnchorScrollProvider() { |
| |
| var autoScrollingEnabled = true; |
| |
| /** |
| * @ngdoc method |
| * @name $anchorScrollProvider#disableAutoScrolling |
| * |
| * @description |
| * By default, {@link ng.$anchorScroll $anchorScroll()} will automatically detect changes to |
| * {@link ng.$location#hash $location.hash()} and scroll to the element matching the new hash.<br /> |
| * Use this method to disable automatic scrolling. |
| * |
| * If automatic scrolling is disabled, one must explicitly call |
| * {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the |
| * current hash. |
| */ |
| this.disableAutoScrolling = function() { |
| autoScrollingEnabled = false; |
| }; |
| |
| /** |
| * @ngdoc service |
| * @name $anchorScroll |
| * @kind function |
| * @requires $window |
| * @requires $location |
| * @requires $rootScope |
| * |
| * @description |
| * When called, it scrolls to the element related to the specified `hash` or (if omitted) to the |
| * current value of {@link ng.$location#hash $location.hash()}, according to the rules specified |
| * in the |
| * [HTML5 spec](http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document). |
| * |
| * It also watches the {@link ng.$location#hash $location.hash()} and automatically scrolls to |
| * match any anchor whenever it changes. This can be disabled by calling |
| * {@link ng.$anchorScrollProvider#disableAutoScrolling $anchorScrollProvider.disableAutoScrolling()}. |
| * |
| * Additionally, you can use its {@link ng.$anchorScroll#yOffset yOffset} property to specify a |
| * vertical scroll-offset (either fixed or dynamic). |
| * |
| * @param {string=} hash The hash specifying the element to scroll to. If omitted, the value of |
| * {@link ng.$location#hash $location.hash()} will be used. |
| * |
| * @property {(number|function|jqLite)} yOffset |
| * If set, specifies a vertical scroll-offset. This is often useful when there are fixed |
| * positioned elements at the top of the page, such as navbars, headers etc. |
| * |
| * `yOffset` can be specified in various ways: |
| * - **number**: A fixed number of pixels to be used as offset.<br /><br /> |
| * - **function**: A getter function called everytime `$anchorScroll()` is executed. Must return |
| * a number representing the offset (in pixels).<br /><br /> |
| * - **jqLite**: A jqLite/jQuery element to be used for specifying the offset. The distance from |
| * the top of the page to the element's bottom will be used as offset.<br /> |
| * **Note**: The element will be taken into account only as long as its `position` is set to |
| * `fixed`. This option is useful, when dealing with responsive navbars/headers that adjust |
| * their height and/or positioning according to the viewport's size. |
| * |
| * <br /> |
| * <div class="alert alert-warning"> |
| * In order for `yOffset` to work properly, scrolling should take place on the document's root and |
| * not some child element. |
| * </div> |
| * |
| * @example |
| <example module="anchorScrollExample"> |
| <file name="index.html"> |
| <div id="scrollArea" ng-controller="ScrollController"> |
| <a ng-click="gotoBottom()">Go to bottom</a> |
| <a id="bottom"></a> You're at the bottom! |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('anchorScrollExample', []) |
| .controller('ScrollController', ['$scope', '$location', '$anchorScroll', |
| function ($scope, $location, $anchorScroll) { |
| $scope.gotoBottom = function() { |
| // set the location.hash to the id of |
| // the element you wish to scroll to. |
| $location.hash('bottom'); |
| |
| // call $anchorScroll() |
| $anchorScroll(); |
| }; |
| }]); |
| </file> |
| <file name="style.css"> |
| #scrollArea { |
| height: 280px; |
| overflow: auto; |
| } |
| |
| #bottom { |
| display: block; |
| margin-top: 2000px; |
| } |
| </file> |
| </example> |
| * |
| * <hr /> |
| * The example below illustrates the use of a vertical scroll-offset (specified as a fixed value). |
| * See {@link ng.$anchorScroll#yOffset $anchorScroll.yOffset} for more details. |
| * |
| * @example |
| <example module="anchorScrollOffsetExample"> |
| <file name="index.html"> |
| <div class="fixed-header" ng-controller="headerCtrl"> |
| <a href="" ng-click="gotoAnchor(x)" ng-repeat="x in [1,2,3,4,5]"> |
| Go to anchor {{x}} |
| </a> |
| </div> |
| <div id="anchor{{x}}" class="anchor" ng-repeat="x in [1,2,3,4,5]"> |
| Anchor {{x}} of 5 |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('anchorScrollOffsetExample', []) |
| .run(['$anchorScroll', function($anchorScroll) { |
| $anchorScroll.yOffset = 50; // always scroll by 50 extra pixels |
| }]) |
| .controller('headerCtrl', ['$anchorScroll', '$location', '$scope', |
| function ($anchorScroll, $location, $scope) { |
| $scope.gotoAnchor = function(x) { |
| var newHash = 'anchor' + x; |
| if ($location.hash() !== newHash) { |
| // set the $location.hash to `newHash` and |
| // $anchorScroll will automatically scroll to it |
| $location.hash('anchor' + x); |
| } else { |
| // call $anchorScroll() explicitly, |
| // since $location.hash hasn't changed |
| $anchorScroll(); |
| } |
| }; |
| } |
| ]); |
| </file> |
| <file name="style.css"> |
| body { |
| padding-top: 50px; |
| } |
| |
| .anchor { |
| border: 2px dashed DarkOrchid; |
| padding: 10px 10px 200px 10px; |
| } |
| |
| .fixed-header { |
| background-color: rgba(0, 0, 0, 0.2); |
| height: 50px; |
| position: fixed; |
| top: 0; left: 0; right: 0; |
| } |
| |
| .fixed-header > a { |
| display: inline-block; |
| margin: 5px 15px; |
| } |
| </file> |
| </example> |
| */ |
| this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) { |
| var document = $window.document; |
| |
| // Helper function to get first anchor from a NodeList |
| // (using `Array#some()` instead of `angular#forEach()` since it's more performant |
| // and working in all supported browsers.) |
| function getFirstAnchor(list) { |
| var result = null; |
| Array.prototype.some.call(list, function(element) { |
| if (nodeName_(element) === 'a') { |
| result = element; |
| return true; |
| } |
| }); |
| return result; |
| } |
| |
| function getYOffset() { |
| |
| var offset = scroll.yOffset; |
| |
| if (isFunction(offset)) { |
| offset = offset(); |
| } else if (isElement(offset)) { |
| var elem = offset[0]; |
| var style = $window.getComputedStyle(elem); |
| if (style.position !== 'fixed') { |
| offset = 0; |
| } else { |
| offset = elem.getBoundingClientRect().bottom; |
| } |
| } else if (!isNumber(offset)) { |
| offset = 0; |
| } |
| |
| return offset; |
| } |
| |
| function scrollTo(elem) { |
| if (elem) { |
| elem.scrollIntoView(); |
| |
| var offset = getYOffset(); |
| |
| if (offset) { |
| // `offset` is the number of pixels we should scroll UP in order to align `elem` properly. |
| // This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the |
| // top of the viewport. |
| // |
| // IF the number of pixels from the top of `elem` to the end of the page's content is less |
| // than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some |
| // way down the page. |
| // |
| // This is often the case for elements near the bottom of the page. |
| // |
| // In such cases we do not need to scroll the whole `offset` up, just the difference between |
| // the top of the element and the offset, which is enough to align the top of `elem` at the |
| // desired position. |
| var elemTop = elem.getBoundingClientRect().top; |
| $window.scrollBy(0, elemTop - offset); |
| } |
| } else { |
| $window.scrollTo(0, 0); |
| } |
| } |
| |
| function scroll(hash) { |
| hash = isString(hash) ? hash : $location.hash(); |
| var elm; |
| |
| // empty hash, scroll to the top of the page |
| if (!hash) scrollTo(null); |
| |
| // element with given id |
| else if ((elm = document.getElementById(hash))) scrollTo(elm); |
| |
| // first anchor with given name :-D |
| else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) scrollTo(elm); |
| |
| // no element and hash == 'top', scroll to the top of the page |
| else if (hash === 'top') scrollTo(null); |
| } |
| |
| // does not scroll when user clicks on anchor link that is currently on |
| // (no url change, no $location.hash() change), browser native does scroll |
| if (autoScrollingEnabled) { |
| $rootScope.$watch(function autoScrollWatch() {return $location.hash();}, |
| function autoScrollWatchAction(newVal, oldVal) { |
| // skip the initial scroll if $location.hash is empty |
| if (newVal === oldVal && newVal === '') return; |
| |
| jqLiteDocumentLoaded(function() { |
| $rootScope.$evalAsync(scroll); |
| }); |
| }); |
| } |
| |
| return scroll; |
| }]; |
| } |
| |
| var $animateMinErr = minErr('$animate'); |
| var ELEMENT_NODE = 1; |
| var NG_ANIMATE_CLASSNAME = 'ng-animate'; |
| |
| function mergeClasses(a,b) { |
| if (!a && !b) return ''; |
| if (!a) return b; |
| if (!b) return a; |
| if (isArray(a)) a = a.join(' '); |
| if (isArray(b)) b = b.join(' '); |
| return a + ' ' + b; |
| } |
| |
| function extractElementNode(element) { |
| for (var i = 0; i < element.length; i++) { |
| var elm = element[i]; |
| if (elm.nodeType === ELEMENT_NODE) { |
| return elm; |
| } |
| } |
| } |
| |
| function splitClasses(classes) { |
| if (isString(classes)) { |
| classes = classes.split(' '); |
| } |
| |
| // Use createMap() to prevent class assumptions involving property names in |
| // Object.prototype |
| var obj = createMap(); |
| forEach(classes, function(klass) { |
| // sometimes the split leaves empty string values |
| // incase extra spaces were applied to the options |
| if (klass.length) { |
| obj[klass] = true; |
| } |
| }); |
| return obj; |
| } |
| |
| // if any other type of options value besides an Object value is |
| // passed into the $animate.method() animation then this helper code |
| // will be run which will ignore it. While this patch is not the |
| // greatest solution to this, a lot of existing plugins depend on |
| // $animate to either call the callback (< 1.2) or return a promise |
| // that can be changed. This helper function ensures that the options |
| // are wiped clean incase a callback function is provided. |
| function prepareAnimateOptions(options) { |
| return isObject(options) |
| ? options |
| : {}; |
| } |
| |
| var $$CoreAnimateRunnerProvider = function() { |
| this.$get = ['$q', '$$rAF', function($q, $$rAF) { |
| function AnimateRunner() {} |
| AnimateRunner.all = noop; |
| AnimateRunner.chain = noop; |
| AnimateRunner.prototype = { |
| end: noop, |
| cancel: noop, |
| resume: noop, |
| pause: noop, |
| complete: noop, |
| then: function(pass, fail) { |
| return $q(function(resolve) { |
| $$rAF(function() { |
| resolve(); |
| }); |
| }).then(pass, fail); |
| } |
| }; |
| return AnimateRunner; |
| }]; |
| }; |
| |
| // this is prefixed with Core since it conflicts with |
| // the animateQueueProvider defined in ngAnimate/animateQueue.js |
| var $$CoreAnimateQueueProvider = function() { |
| var postDigestQueue = new HashMap(); |
| var postDigestElements = []; |
| |
| this.$get = ['$$AnimateRunner', '$rootScope', |
| function($$AnimateRunner, $rootScope) { |
| return { |
| enabled: noop, |
| on: noop, |
| off: noop, |
| pin: noop, |
| |
| push: function(element, event, options, domOperation) { |
| domOperation && domOperation(); |
| |
| options = options || {}; |
| options.from && element.css(options.from); |
| options.to && element.css(options.to); |
| |
| if (options.addClass || options.removeClass) { |
| addRemoveClassesPostDigest(element, options.addClass, options.removeClass); |
| } |
| |
| return new $$AnimateRunner(); // jshint ignore:line |
| } |
| }; |
| |
| |
| function updateData(data, classes, value) { |
| var changed = false; |
| if (classes) { |
| classes = isString(classes) ? classes.split(' ') : |
| isArray(classes) ? classes : []; |
| forEach(classes, function(className) { |
| if (className) { |
| changed = true; |
| data[className] = value; |
| } |
| }); |
| } |
| return changed; |
| } |
| |
| function handleCSSClassChanges() { |
| forEach(postDigestElements, function(element) { |
| var data = postDigestQueue.get(element); |
| if (data) { |
| var existing = splitClasses(element.attr('class')); |
| var toAdd = ''; |
| var toRemove = ''; |
| forEach(data, function(status, className) { |
| var hasClass = !!existing[className]; |
| if (status !== hasClass) { |
| if (status) { |
| toAdd += (toAdd.length ? ' ' : '') + className; |
| } else { |
| toRemove += (toRemove.length ? ' ' : '') + className; |
| } |
| } |
| }); |
| |
| forEach(element, function(elm) { |
| toAdd && jqLiteAddClass(elm, toAdd); |
| toRemove && jqLiteRemoveClass(elm, toRemove); |
| }); |
| postDigestQueue.remove(element); |
| } |
| }); |
| postDigestElements.length = 0; |
| } |
| |
| |
| function addRemoveClassesPostDigest(element, add, remove) { |
| var data = postDigestQueue.get(element) || {}; |
| |
| var classesAdded = updateData(data, add, true); |
| var classesRemoved = updateData(data, remove, false); |
| |
| if (classesAdded || classesRemoved) { |
| |
| postDigestQueue.put(element, data); |
| postDigestElements.push(element); |
| |
| if (postDigestElements.length === 1) { |
| $rootScope.$$postDigest(handleCSSClassChanges); |
| } |
| } |
| } |
| }]; |
| }; |
| |
| /** |
| * @ngdoc provider |
| * @name $animateProvider |
| * |
| * @description |
| * Default implementation of $animate that doesn't perform any animations, instead just |
| * synchronously performs DOM updates and resolves the returned runner promise. |
| * |
| * In order to enable animations the `ngAnimate` module has to be loaded. |
| * |
| * To see the functional implementation check out `src/ngAnimate/animate.js`. |
| */ |
| var $AnimateProvider = ['$provide', function($provide) { |
| var provider = this; |
| |
| this.$$registeredAnimations = Object.create(null); |
| |
| /** |
| * @ngdoc method |
| * @name $animateProvider#register |
| * |
| * @description |
| * Registers a new injectable animation factory function. The factory function produces the |
| * animation object which contains callback functions for each event that is expected to be |
| * animated. |
| * |
| * * `eventFn`: `function(element, ... , doneFunction, options)` |
| * The element to animate, the `doneFunction` and the options fed into the animation. Depending |
| * on the type of animation additional arguments will be injected into the animation function. The |
| * list below explains the function signatures for the different animation methods: |
| * |
| * - setClass: function(element, addedClasses, removedClasses, doneFunction, options) |
| * - addClass: function(element, addedClasses, doneFunction, options) |
| * - removeClass: function(element, removedClasses, doneFunction, options) |
| * - enter, leave, move: function(element, doneFunction, options) |
| * - animate: function(element, fromStyles, toStyles, doneFunction, options) |
| * |
| * Make sure to trigger the `doneFunction` once the animation is fully complete. |
| * |
| * ```js |
| * return { |
| * //enter, leave, move signature |
| * eventFn : function(element, done, options) { |
| * //code to run the animation |
| * //once complete, then run done() |
| * return function endFunction(wasCancelled) { |
| * //code to cancel the animation |
| * } |
| * } |
| * } |
| * ``` |
| * |
| * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to). |
| * @param {Function} factory The factory function that will be executed to return the animation |
| * object. |
| */ |
| this.register = function(name, factory) { |
| if (name && name.charAt(0) !== '.') { |
| throw $animateMinErr('notcsel', "Expecting class selector starting with '.' got '{0}'.", name); |
| } |
| |
| var key = name + '-animation'; |
| provider.$$registeredAnimations[name.substr(1)] = key; |
| $provide.factory(key, factory); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $animateProvider#classNameFilter |
| * |
| * @description |
| * Sets and/or returns the CSS class regular expression that is checked when performing |
| * an animation. Upon bootstrap the classNameFilter value is not set at all and will |
| * therefore enable $animate to attempt to perform an animation on any element that is triggered. |
| * When setting the `classNameFilter` value, animations will only be performed on elements |
| * that successfully match the filter expression. This in turn can boost performance |
| * for low-powered devices as well as applications containing a lot of structural operations. |
| * @param {RegExp=} expression The className expression which will be checked against all animations |
| * @return {RegExp} The current CSS className expression value. If null then there is no expression value |
| */ |
| this.classNameFilter = function(expression) { |
| if (arguments.length === 1) { |
| this.$$classNameFilter = (expression instanceof RegExp) ? expression : null; |
| if (this.$$classNameFilter) { |
| var reservedRegex = new RegExp("(\\s+|\\/)" + NG_ANIMATE_CLASSNAME + "(\\s+|\\/)"); |
| if (reservedRegex.test(this.$$classNameFilter.toString())) { |
| throw $animateMinErr('nongcls','$animateProvider.classNameFilter(regex) prohibits accepting a regex value which matches/contains the "{0}" CSS class.', NG_ANIMATE_CLASSNAME); |
| |
| } |
| } |
| } |
| return this.$$classNameFilter; |
| }; |
| |
| this.$get = ['$$animateQueue', function($$animateQueue) { |
| function domInsert(element, parentElement, afterElement) { |
| // if for some reason the previous element was removed |
| // from the dom sometime before this code runs then let's |
| // just stick to using the parent element as the anchor |
| if (afterElement) { |
| var afterNode = extractElementNode(afterElement); |
| if (afterNode && !afterNode.parentNode && !afterNode.previousElementSibling) { |
| afterElement = null; |
| } |
| } |
| afterElement ? afterElement.after(element) : parentElement.prepend(element); |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $animate |
| * @description The $animate service exposes a series of DOM utility methods that provide support |
| * for animation hooks. The default behavior is the application of DOM operations, however, |
| * when an animation is detected (and animations are enabled), $animate will do the heavy lifting |
| * to ensure that animation runs with the triggered DOM operation. |
| * |
| * By default $animate doesn't trigger an animations. This is because the `ngAnimate` module isn't |
| * included and only when it is active then the animation hooks that `$animate` triggers will be |
| * functional. Once active then all structural `ng-` directives will trigger animations as they perform |
| * their DOM-related operations (enter, leave and move). Other directives such as `ngClass`, |
| * `ngShow`, `ngHide` and `ngMessages` also provide support for animations. |
| * |
| * It is recommended that the`$animate` service is always used when executing DOM-related procedures within directives. |
| * |
| * To learn more about enabling animation support, click here to visit the |
| * {@link ngAnimate ngAnimate module page}. |
| */ |
| return { |
| // we don't call it directly since non-existant arguments may |
| // be interpreted as null within the sub enabled function |
| |
| /** |
| * |
| * @ngdoc method |
| * @name $animate#on |
| * @kind function |
| * @description Sets up an event listener to fire whenever the animation event (enter, leave, move, etc...) |
| * has fired on the given element or among any of its children. Once the listener is fired, the provided callback |
| * is fired with the following params: |
| * |
| * ```js |
| * $animate.on('enter', container, |
| * function callback(element, phase) { |
| * // cool we detected an enter animation within the container |
| * } |
| * ); |
| * ``` |
| * |
| * @param {string} event the animation event that will be captured (e.g. enter, leave, move, addClass, removeClass, etc...) |
| * @param {DOMElement} container the container element that will capture each of the animation events that are fired on itself |
| * as well as among its children |
| * @param {Function} callback the callback function that will be fired when the listener is triggered |
| * |
| * The arguments present in the callback function are: |
| * * `element` - The captured DOM element that the animation was fired on. |
| * * `phase` - The phase of the animation. The two possible phases are **start** (when the animation starts) and **close** (when it ends). |
| */ |
| on: $$animateQueue.on, |
| |
| /** |
| * |
| * @ngdoc method |
| * @name $animate#off |
| * @kind function |
| * @description Deregisters an event listener based on the event which has been associated with the provided element. This method |
| * can be used in three different ways depending on the arguments: |
| * |
| * ```js |
| * // remove all the animation event listeners listening for `enter` |
| * $animate.off('enter'); |
| * |
| * // remove all the animation event listeners listening for `enter` on the given element and its children |
| * $animate.off('enter', container); |
| * |
| * // remove the event listener function provided by `listenerFn` that is set |
| * // to listen for `enter` on the given `element` as well as its children |
| * $animate.off('enter', container, callback); |
| * ``` |
| * |
| * @param {string} event the animation event (e.g. enter, leave, move, addClass, removeClass, etc...) |
| * @param {DOMElement=} container the container element the event listener was placed on |
| * @param {Function=} callback the callback function that was registered as the listener |
| */ |
| off: $$animateQueue.off, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#pin |
| * @kind function |
| * @description Associates the provided element with a host parent element to allow the element to be animated even if it exists |
| * outside of the DOM structure of the Angular application. By doing so, any animation triggered via `$animate` can be issued on the |
| * element despite being outside the realm of the application or within another application. Say for example if the application |
| * was bootstrapped on an element that is somewhere inside of the `<body>` tag, but we wanted to allow for an element to be situated |
| * as a direct child of `document.body`, then this can be achieved by pinning the element via `$animate.pin(element)`. Keep in mind |
| * that calling `$animate.pin(element, parentElement)` will not actually insert into the DOM anywhere; it will just create the association. |
| * |
| * Note that this feature is only active when the `ngAnimate` module is used. |
| * |
| * @param {DOMElement} element the external element that will be pinned |
| * @param {DOMElement} parentElement the host parent element that will be associated with the external element |
| */ |
| pin: $$animateQueue.pin, |
| |
| /** |
| * |
| * @ngdoc method |
| * @name $animate#enabled |
| * @kind function |
| * @description Used to get and set whether animations are enabled or not on the entire application or on an element and its children. This |
| * function can be called in four ways: |
| * |
| * ```js |
| * // returns true or false |
| * $animate.enabled(); |
| * |
| * // changes the enabled state for all animations |
| * $animate.enabled(false); |
| * $animate.enabled(true); |
| * |
| * // returns true or false if animations are enabled for an element |
| * $animate.enabled(element); |
| * |
| * // changes the enabled state for an element and its children |
| * $animate.enabled(element, true); |
| * $animate.enabled(element, false); |
| * ``` |
| * |
| * @param {DOMElement=} element the element that will be considered for checking/setting the enabled state |
| * @param {boolean=} enabled whether or not the animations will be enabled for the element |
| * |
| * @return {boolean} whether or not animations are enabled |
| */ |
| enabled: $$animateQueue.enabled, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#cancel |
| * @kind function |
| * @description Cancels the provided animation. |
| * |
| * @param {Promise} animationPromise The animation promise that is returned when an animation is started. |
| */ |
| cancel: function(runner) { |
| runner.end && runner.end(); |
| }, |
| |
| /** |
| * |
| * @ngdoc method |
| * @name $animate#enter |
| * @kind function |
| * @description Inserts the element into the DOM either after the `after` element (if provided) or |
| * as the first child within the `parent` element and then triggers an animation. |
| * A promise is returned that will be resolved during the next digest once the animation |
| * has completed. |
| * |
| * @param {DOMElement} element the element which will be inserted into the DOM |
| * @param {DOMElement} parent the parent element which will append the element as |
| * a child (so long as the after element is not present) |
| * @param {DOMElement=} after the sibling element after which the element will be appended |
| * @param {object=} options an optional collection of options/styles that will be applied to the element |
| * |
| * @return {Promise} the animation callback promise |
| */ |
| enter: function(element, parent, after, options) { |
| parent = parent && jqLite(parent); |
| after = after && jqLite(after); |
| parent = parent || after.parent(); |
| domInsert(element, parent, after); |
| return $$animateQueue.push(element, 'enter', prepareAnimateOptions(options)); |
| }, |
| |
| /** |
| * |
| * @ngdoc method |
| * @name $animate#move |
| * @kind function |
| * @description Inserts (moves) the element into its new position in the DOM either after |
| * the `after` element (if provided) or as the first child within the `parent` element |
| * and then triggers an animation. A promise is returned that will be resolved |
| * during the next digest once the animation has completed. |
| * |
| * @param {DOMElement} element the element which will be moved into the new DOM position |
| * @param {DOMElement} parent the parent element which will append the element as |
| * a child (so long as the after element is not present) |
| * @param {DOMElement=} after the sibling element after which the element will be appended |
| * @param {object=} options an optional collection of options/styles that will be applied to the element |
| * |
| * @return {Promise} the animation callback promise |
| */ |
| move: function(element, parent, after, options) { |
| parent = parent && jqLite(parent); |
| after = after && jqLite(after); |
| parent = parent || after.parent(); |
| domInsert(element, parent, after); |
| return $$animateQueue.push(element, 'move', prepareAnimateOptions(options)); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#leave |
| * @kind function |
| * @description Triggers an animation and then removes the element from the DOM. |
| * When the function is called a promise is returned that will be resolved during the next |
| * digest once the animation has completed. |
| * |
| * @param {DOMElement} element the element which will be removed from the DOM |
| * @param {object=} options an optional collection of options/styles that will be applied to the element |
| * |
| * @return {Promise} the animation callback promise |
| */ |
| leave: function(element, options) { |
| return $$animateQueue.push(element, 'leave', prepareAnimateOptions(options), function() { |
| element.remove(); |
| }); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#addClass |
| * @kind function |
| * |
| * @description Triggers an addClass animation surrounding the addition of the provided CSS class(es). Upon |
| * execution, the addClass operation will only be handled after the next digest and it will not trigger an |
| * animation if element already contains the CSS class or if the class is removed 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 added (multiple classes are separated via spaces) |
| * @param {object=} options an optional collection of options/styles that will be applied to the element |
| * |
| * @return {Promise} the animation callback promise |
| */ |
| addClass: function(element, className, options) { |
| options = prepareAnimateOptions(options); |
| options.addClass = mergeClasses(options.addclass, className); |
| return $$animateQueue.push(element, 'addClass', options); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $animate#removeClass |
| * @kind function |
| * |
| * @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 |
| * |
| * @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 |
| * |
| * @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 a JavaScript animation is detected then the provided styles |
| * will be given in as function paramters into the `animate` method (or as apart of the `options` parameter). |
| * |
| * @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 appplied to the element.) |
| * @param {object=} options an optional collection of options/styles that will be applied to the element |
| * |
| * @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); |
| } |
| }; |
| }]; |
| }]; |
| |
| /** |
| * @ngdoc service |
| * @name $animateCss |
| * @kind object |
| * |
| * @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', function($$rAF, $q) { |
| |
| var RAFPromise = function() {}; |
| RAFPromise.prototype = { |
| done: function(cancel) { |
| this.defer && this.defer[cancel === true ? 'reject' : 'resolve'](); |
| }, |
| end: function() { |
| this.done(); |
| }, |
| cancel: function() { |
| this.done(true); |
| }, |
| getPromise: function() { |
| if (!this.defer) { |
| this.defer = $q.defer(); |
| } |
| return this.defer.promise; |
| }, |
| then: function(f1,f2) { |
| return this.getPromise().then(f1,f2); |
| }, |
| 'catch': function(f1) { |
| return this.getPromise()['catch'](f1); |
| }, |
| 'finally': function(f1) { |
| return this.getPromise()['finally'](f1); |
| } |
| }; |
| |
| return function(element, 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 RAFPromise(); |
| return { |
| start: run, |
| end: run |
| }; |
| |
| function run() { |
| $$rAF(function() { |
| close(); |
| if (!closed) { |
| runner.done(); |
| } |
| closed = true; |
| }); |
| return runner; |
| } |
| |
| function close() { |
| 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, |
| rawDocument = document[0], |
| 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 |
| * Note: this method is used only by scenario runner |
| * 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; |
| |
| cacheState(); |
| lastHistoryState = cachedState; |
| |
| /** |
| * @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; |
| |
| // setter |
| if (url) { |
| var sameState = lastHistoryState === state; |
| |
| // Don't change anything if previous and current URLs and states match. This also prevents |
| // IE<10 from getting into redirect loop when in LocationHashbangInHtml5Url mode. |
| // See https://github.com/angular/angular.js/commit/ffb2701 |
| if (lastBrowserUrl === url && (!$sniffer.history || sameState)) { |
| return self; |
| } |
| var sameBase = lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url); |
| lastBrowserUrl = url; |
| lastHistoryState = state; |
| // Don't use history API if only the hash changed |
| // due to a bug in IE10/IE11 which leads |
| // to not firing a `hashchange` nor `popstate` event |
| // in some cases (see #9143). |
| if ($sniffer.history && (!sameBase || !sameState)) { |
| history[replace ? 'replaceState' : 'pushState'](state, '', url); |
| cacheState(); |
| // Do the assignment again so that those two variables are referentially identical. |
| lastHistoryState = cachedState; |
| } else { |
| if (!sameBase || pendingLocation) { |
| pendingLocation = url; |
| } |
| if (replace) { |
| location.replace(url); |
| } else if (!sameBase) { |
| location.href = url; |
| } else { |
| location.hash = getHash(url); |
| } |
| if (location.href !== url) { |
| pendingLocation = url; |
| } |
| } |
| return self; |
| // getter |
| } else { |
| // - pendingLocation is needed as browsers don't allow to read out |
| // the new location.href if a reload happened or if there is a bug like in iOS 9 (see |
| // https://openradar.appspot.com/22186109). |
| // - the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172 |
| return pendingLocation || location.href.replace(/%27/g,"'"); |
| } |
| }; |
| |
| /** |
| * @name $browser#state |
| * |
| * @description |
| * This method is a getter. |
| * |
| * Return history.state or null if history.state is undefined. |
| * |
| * @returns {object} state |
| */ |
| self.state = function() { |
| return cachedState; |
| }; |
| |
| var urlChangeListeners = [], |
| urlChangeInit = false; |
| |
| function cacheStateAndFireUrlChange() { |
| pendingLocation = null; |
| cacheState(); |
| fireUrlChange(); |
| } |
| |
| function getCurrentState() { |
| try { |
| return history.state; |
| } catch (e) { |
| // MSIE can reportedly throw when there is no state (UNCONFIRMED). |
| } |
| } |
| |
| // This variable should be used *only* inside the cacheState function. |
| var lastCachedState = null; |
| function cacheState() { |
| // This should be the only place in $browser where `history.state` is read. |
| cachedState = getCurrentState(); |
| cachedState = isUndefined(cachedState) ? null : cachedState; |
| |
| // Prevent callbacks fo fire twice if both hashchange & popstate were fired. |
| if (equals(cachedState, lastCachedState)) { |
| cachedState = lastCachedState; |
| } |
| lastCachedState = cachedState; |
| } |
| |
| function fireUrlChange() { |
| if (lastBrowserUrl === self.url() && lastHistoryState === cachedState) { |
| return; |
| } |
| |
| lastBrowserUrl = self.url(); |
| lastHistoryState = cachedState; |
| forEach(urlChangeListeners, function(listener) { |
| listener(self.url(), cachedState); |
| }); |
| } |
| |
| /** |
| * @name $browser#onUrlChange |
| * |
| * @description |
| * Register callback function that will be called, when url changes. |
| * |
| * It's only called when the url is changed from outside of angular: |
| * - user types different url into address bar |
| * - user clicks on history (forward/back) button |
| * - user clicks on a link |
| * |
| * It's not called when url is changed by $browser.url() method |
| * |
| * The listener gets called with new url as parameter. |
| * |
| * NOTE: this api is intended for use only by the $location service. Please use the |
| * {@link ng.$location $location service} to monitor url changes in angular apps. |
| * |
| * @param {function(string)} listener Listener function to be called when url changes. |
| * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous. |
| */ |
| self.onUrlChange = function(callback) { |
| // TODO(vojta): refactor to use node's syntax for events |
| if (!urlChangeInit) { |
| // We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera) |
| // don't fire popstate when user change the address bar and don't fire hashchange when url |
| // changed by push/replaceState |
| |
| // html5 history api - popstate event |
| if ($sniffer.history) jqLite(window).on('popstate', cacheStateAndFireUrlChange); |
| // hashchange event |
| jqLite(window).on('hashchange', cacheStateAndFireUrlChange); |
| |
| urlChangeInit = true; |
| } |
| |
| urlChangeListeners.push(callback); |
| return callback; |
| }; |
| |
| /** |
| * @private |
| * Remove popstate and hashchange handler from window. |
| * |
| * NOTE: this api is intended for use only by $rootScope. |
| */ |
| self.$$applicationDestroyed = function() { |
| jqLite(window).off('hashchange popstate', cacheStateAndFireUrlChange); |
| }; |
| |
| /** |
| * Checks whether the url has changed outside of Angular. |
| * Needs to be exported to be able to check for changes that have been done in sync, |
| * as hashchange/popstate events fire in async. |
| */ |
| self.$$checkUrlChange = fireUrlChange; |
| |
| ////////////////////////////////////////////////////////////// |
| // Misc API |
| ////////////////////////////////////////////////////////////// |
| |
| /** |
| * @name $browser#baseHref |
| * |
| * @description |
| * Returns current <base href> |
| * (always relative - without domain) |
| * |
| * @returns {string} The current base href |
| */ |
| self.baseHref = function() { |
| var href = baseElement.attr('href'); |
| return href ? href.replace(/^(https?\:)?\/\/[^\/]*/, '') : ''; |
| }; |
| |
| /** |
| * @name $browser#defer |
| * @param {function()} fn A function, who's execution should be deferred. |
| * @param {number=} [delay=0] of milliseconds to defer the function execution. |
| * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`. |
| * |
| * @description |
| * Executes a fn asynchronously via `setTimeout(fn, delay)`. |
| * |
| * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using |
| * `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed |
| * via `$browser.defer.flush()`. |
| * |
| */ |
| self.defer = function(fn, delay) { |
| var timeoutId; |
| outstandingRequestCount++; |
| timeoutId = setTimeout(function() { |
| delete pendingDeferIds[timeoutId]; |
| completeOutstandingRequest(fn); |
| }, delay || 0); |
| pendingDeferIds[timeoutId] = true; |
| return timeoutId; |
| }; |
| |
| |
| /** |
| * @name $browser#defer.cancel |
| * |
| * @description |
| * Cancels a deferred task identified with `deferId`. |
| * |
| * @param {*} deferId Token returned by the `$browser.defer` function. |
| * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully |
| * canceled. |
| */ |
| self.defer.cancel = function(deferId) { |
| if (pendingDeferIds[deferId]) { |
| delete pendingDeferIds[deferId]; |
| clearTimeout(deferId); |
| completeOutstandingRequest(noop); |
| return true; |
| } |
| return false; |
| }; |
| |
| } |
| |
| function $BrowserProvider() { |
| this.$get = ['$window', '$log', '$sniffer', '$document', |
| function($window, $log, $sniffer, $document) { |
| return new Browser($window, $document, $log, $sniffer); |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $cacheFactory |
| * |
| * @description |
| * Factory that constructs {@link $cacheFactory.Cache Cache} objects and gives access to |
| * them. |
| * |
| * ```js |
| * |
| * var cache = $cacheFactory('cacheId'); |
| * expect($cacheFactory.get('cacheId')).toBe(cache); |
| * expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined(); |
| * |
| * cache.put("key", "value"); |
| * cache.put("another key", "another value"); |
| * |
| * // We've specified no options on creation |
| * expect(cache.info()).toEqual({id: 'cacheId', size: 2}); |
| * |
| * ``` |
| * |
| * |
| * @param {string} cacheId Name or id of the newly created cache. |
| * @param {object=} options Options object that specifies the cache behavior. Properties: |
| * |
| * - `{number=}` `capacity` — turns the cache into LRU cache. |
| * |
| * @returns {object} Newly created cache object with the following set of methods: |
| * |
| * - `{object}` `info()` — Returns id, size, and options of cache. |
| * - `{{*}}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache and returns |
| * it. |
| * - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss. |
| * - `{void}` `remove({string} key)` — Removes a key-value pair from the cache. |
| * - `{void}` `removeAll()` — Removes all cached values. |
| * - `{void}` `destroy()` — Removes references to this cache from $cacheFactory. |
| * |
| * @example |
| <example module="cacheExampleApp"> |
| <file name="index.html"> |
| <div ng-controller="CacheController"> |
| <input ng-model="newCacheKey" placeholder="Key"> |
| <input ng-model="newCacheValue" placeholder="Value"> |
| <button ng-click="put(newCacheKey, newCacheValue)">Cache</button> |
| |
| <p ng-if="keys.length">Cached Values</p> |
| <div ng-repeat="key in keys"> |
| <span ng-bind="key"></span> |
| <span>: </span> |
| <b ng-bind="cache.get(key)"></b> |
| </div> |
| |
| <p>Cache Info</p> |
| <div ng-repeat="(key, value) in cache.info()"> |
| <span ng-bind="key"></span> |
| <span>: </span> |
| <b ng-bind="value"></b> |
| </div> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('cacheExampleApp', []). |
| controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) { |
| $scope.keys = []; |
| $scope.cache = $cacheFactory('cacheId'); |
| $scope.put = function(key, value) { |
| if (angular.isUndefined($scope.cache.get(key))) { |
| $scope.keys.push(key); |
| } |
| $scope.cache.put(key, angular.isUndefined(value) ? null : value); |
| }; |
| }]); |
| </file> |
| <file name="style.css"> |
| p { |
| margin: 10px 0 3px; |
| } |
| </file> |
| </example> |
| */ |
| function $CacheFactoryProvider() { |
| |
| this.$get = function() { |
| var caches = {}; |
| |
| function cacheFactory(cacheId, options) { |
| if (cacheId in caches) { |
| throw minErr('$cacheFactory')('iid', "CacheId '{0}' is already taken!", cacheId); |
| } |
| |
| var size = 0, |
| stats = extend({}, options, {id: cacheId}), |
| data = {}, |
| capacity = (options && options.capacity) || Number.MAX_VALUE, |
| lruHash = {}, |
| freshEnd = null, |
| staleEnd = null; |
| |
| /** |
| * @ngdoc type |
| * @name $cacheFactory.Cache |
| * |
| * @description |
| * A cache object used to store and retrieve data, primarily used by |
| * {@link $http $http} and the {@link ng.directive:script script} directive to cache |
| * templates and other data. |
| * |
| * ```js |
| * angular.module('superCache') |
| * .factory('superCache', ['$cacheFactory', function($cacheFactory) { |
| * return $cacheFactory('super-cache'); |
| * }]); |
| * ``` |
| * |
| * Example test: |
| * |
| * ```js |
| * it('should behave like a cache', inject(function(superCache) { |
| * superCache.put('key', 'value'); |
| * superCache.put('another key', 'another value'); |
| * |
| * expect(superCache.info()).toEqual({ |
| * id: 'super-cache', |
| * size: 2 |
| * }); |
| * |
| * superCache.remove('another key'); |
| * expect(superCache.get('another key')).toBeUndefined(); |
| * |
| * superCache.removeAll(); |
| * expect(superCache.info()).toEqual({ |
| * id: 'super-cache', |
| * size: 0 |
| * }); |
| * })); |
| * ``` |
| */ |
| return caches[cacheId] = { |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory.Cache#put |
| * @kind function |
| * |
| * @description |
| * Inserts a named entry into the {@link $cacheFactory.Cache Cache} object to be |
| * retrieved later, and incrementing the size of the cache if the key was not already |
| * present in the cache. If behaving like an LRU cache, it will also remove stale |
| * entries from the set. |
| * |
| * It will not insert undefined values into the cache. |
| * |
| * @param {string} key the key under which the cached data is stored. |
| * @param {*} value the value to store alongside the key. If it is undefined, the key |
| * will not be stored. |
| * @returns {*} the value stored. |
| */ |
| put: function(key, value) { |
| if (isUndefined(value)) return; |
| if (capacity < Number.MAX_VALUE) { |
| var lruEntry = lruHash[key] || (lruHash[key] = {key: key}); |
| |
| refresh(lruEntry); |
| } |
| |
| if (!(key in data)) size++; |
| data[key] = value; |
| |
| if (size > capacity) { |
| this.remove(staleEnd.key); |
| } |
| |
| return value; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory.Cache#get |
| * @kind function |
| * |
| * @description |
| * Retrieves named data stored in the {@link $cacheFactory.Cache Cache} object. |
| * |
| * @param {string} key the key of the data to be retrieved |
| * @returns {*} the value stored. |
| */ |
| get: function(key) { |
| if (capacity < Number.MAX_VALUE) { |
| var lruEntry = lruHash[key]; |
| |
| if (!lruEntry) return; |
| |
| refresh(lruEntry); |
| } |
| |
| return data[key]; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory.Cache#remove |
| * @kind function |
| * |
| * @description |
| * Removes an entry from the {@link $cacheFactory.Cache Cache} object. |
| * |
| * @param {string} key the key of the entry to be removed |
| */ |
| remove: function(key) { |
| if (capacity < Number.MAX_VALUE) { |
| var lruEntry = lruHash[key]; |
| |
| if (!lruEntry) return; |
| |
| if (lruEntry == freshEnd) freshEnd = lruEntry.p; |
| if (lruEntry == staleEnd) staleEnd = lruEntry.n; |
| link(lruEntry.n,lruEntry.p); |
| |
| delete lruHash[key]; |
| } |
| |
| delete data[key]; |
| size--; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory.Cache#removeAll |
| * @kind function |
| * |
| * @description |
| * Clears the cache object of any entries. |
| */ |
| removeAll: function() { |
| data = {}; |
| size = 0; |
| lruHash = {}; |
| freshEnd = staleEnd = null; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory.Cache#destroy |
| * @kind function |
| * |
| * @description |
| * Destroys the {@link $cacheFactory.Cache Cache} object entirely, |
| * removing it from the {@link $cacheFactory $cacheFactory} set. |
| */ |
| destroy: function() { |
| data = null; |
| stats = null; |
| lruHash = null; |
| delete caches[cacheId]; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory.Cache#info |
| * @kind function |
| * |
| * @description |
| * Retrieve information regarding a particular {@link $cacheFactory.Cache Cache}. |
| * |
| * @returns {object} an object with the following properties: |
| * <ul> |
| * <li>**id**: the id of the cache instance</li> |
| * <li>**size**: the number of entries kept in the cache instance</li> |
| * <li>**...**: any additional properties from the options object when creating the |
| * cache.</li> |
| * </ul> |
| */ |
| info: function() { |
| return extend({}, stats, {size: size}); |
| } |
| }; |
| |
| |
| /** |
| * makes the `entry` the freshEnd of the LRU linked list |
| */ |
| function refresh(entry) { |
| if (entry != freshEnd) { |
| if (!staleEnd) { |
| staleEnd = entry; |
| } else if (staleEnd == entry) { |
| staleEnd = entry.n; |
| } |
| |
| link(entry.n, entry.p); |
| link(entry, freshEnd); |
| freshEnd = entry; |
| freshEnd.n = null; |
| } |
| } |
| |
| |
| /** |
| * bidirectionally links two entries of the LRU linked list |
| */ |
| function link(nextEntry, prevEntry) { |
| if (nextEntry != prevEntry) { |
| if (nextEntry) nextEntry.p = prevEntry; //p stands for previous, 'prev' didn't minify |
| if (prevEntry) prevEntry.n = nextEntry; //n stands for next, 'next' didn't minify |
| } |
| } |
| } |
| |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory#info |
| * |
| * @description |
| * Get information about all the caches that have been created |
| * |
| * @returns {Object} - key-value map of `cacheId` to the result of calling `cache#info` |
| */ |
| cacheFactory.info = function() { |
| var info = {}; |
| forEach(caches, function(cache, cacheId) { |
| info[cacheId] = cache.info(); |
| }); |
| return info; |
| }; |
| |
| |
| /** |
| * @ngdoc method |
| * @name $cacheFactory#get |
| * |
| * @description |
| * Get access to a cache object by the `cacheId` used when it was created. |
| * |
| * @param {string} cacheId Name or id of a cache to access. |
| * @returns {object} Cache object identified by the cacheId or undefined if no such cache. |
| */ |
| cacheFactory.get = function(cacheId) { |
| return caches[cacheId]; |
| }; |
| |
| |
| return cacheFactory; |
| }; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $templateCache |
| * |
| * @description |
| * The first time a template is used, it is loaded in the template cache for quick retrieval. You |
| * can load templates directly into the cache in a `script` tag, or by consuming the |
| * `$templateCache` service directly. |
| * |
| * Adding via the `script` tag: |
| * |
| * ```html |
| * <script type="text/ng-template" id="templateId.html"> |
| * <p>This is the content of the template</p> |
| * </script> |
| * ``` |
| * |
| * **Note:** the `script` tag containing the template does not need to be included in the `head` of |
| * the document, but it must be a descendent of the {@link ng.$rootElement $rootElement} (IE, |
| * element with ng-app attribute), otherwise the template will be ignored. |
| * |
| * Adding via the `$templateCache` service: |
| * |
| * ```js |
| * var myApp = angular.module('myApp', []); |
| * myApp.run(function($templateCache) { |
| * $templateCache.put('templateId.html', 'This is the content of the template'); |
| * }); |
| * ``` |
| * |
| * To retrieve the template later, simply use it in your HTML: |
| * ```html |
| * <div ng-include=" 'templateId.html' "></div> |
| * ``` |
| * |
| * or get it via Javascript: |
| * ```js |
| * $templateCache.get('templateId.html') |
| * ``` |
| * |
| * See {@link ng.$cacheFactory $cacheFactory}. |
| * |
| */ |
| function $TemplateCacheProvider() { |
| this.$get = ['$cacheFactory', function($cacheFactory) { |
| return $cacheFactory('templates'); |
| }]; |
| } |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Any commits to this file should be reviewed with security in mind. * |
| * Changes to this file can potentially create security vulnerabilities. * |
| * An approval from 2 Core members with history of modifying * |
| * this file is required. * |
| * * |
| * Does the change somehow allow for arbitrary javascript to be executed? * |
| * Or allows for someone to change the prototype of built-in objects? * |
| * Or gives undesired access to variables likes document or window? * |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| /* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE! |
| * |
| * DOM-related variables: |
| * |
| * - "node" - DOM Node |
| * - "element" - DOM Element or Node |
| * - "$node" or "$element" - jqLite-wrapped node or element |
| * |
| * |
| * Compiler related stuff: |
| * |
| * - "linkFn" - linking fn of a single directive |
| * - "nodeLinkFn" - function that aggregates all linking fns for a particular node |
| * - "childLinkFn" - function that aggregates all linking fns for child nodes of a particular node |
| * - "compositeLinkFn" - function that aggregates all linking fns for a compilation root (nodeList) |
| */ |
| |
| |
| /** |
| * @ngdoc service |
| * @name $compile |
| * @kind function |
| * |
| * @description |
| * Compiles an HTML string or DOM into a template and produces a template function, which |
| * can then be used to link {@link ng.$rootScope.Scope `scope`} and the template together. |
| * |
| * The compilation is a process of walking the DOM tree and matching DOM elements to |
| * {@link ng.$compileProvider#directive directives}. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** This document is an in-depth reference of all directive options. |
| * For a gentle introduction to directives with examples of common use cases, |
| * see the {@link guide/directive directive guide}. |
| * </div> |
| * |
| * ## Comprehensive Directive API |
| * |
| * There are many different options for a directive. |
| * |
| * The difference resides in the return value of the factory function. |
| * You can either return a "Directive Definition Object" (see below) that defines the directive properties, |
| * or just the `postLink` function (all other properties will have the default values). |
| * |
| * <div class="alert alert-success"> |
| * **Best Practice:** It's recommended to use the "directive definition object" form. |
| * </div> |
| * |
| * Here's an example directive declared with a Directive Definition Object: |
| * |
| * ```js |
| * var myModule = angular.module(...); |
| * |
| * myModule.directive('directiveName', function factory(injectables) { |
| * var directiveDefinitionObject = { |
| * priority: 0, |
| * template: '<div></div>', // or // function(tElement, tAttrs) { ... }, |
| * // or |
| * // templateUrl: 'directive.html', // or // function(tElement, tAttrs) { ... }, |
| * transclude: false, |
| * restrict: 'A', |
| * templateNamespace: 'html', |
| * scope: false, |
| * controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... }, |
| * controllerAs: 'stringIdentifier', |
| * bindToController: false, |
| * require: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'], |
| * compile: function compile(tElement, tAttrs, transclude) { |
| * return { |
| * pre: function preLink(scope, iElement, iAttrs, controller) { ... }, |
| * post: function postLink(scope, iElement, iAttrs, controller) { ... } |
| * } |
| * // or |
| * // return function postLink( ... ) { ... } |
| * }, |
| * // or |
| * // link: { |
| * // pre: function preLink(scope, iElement, iAttrs, controller) { ... }, |
| * // post: function postLink(scope, iElement, iAttrs, controller) { ... } |
| * // } |
| * // or |
| * // link: function postLink( ... ) { ... } |
| * }; |
| * return directiveDefinitionObject; |
| * }); |
| * ``` |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** Any unspecified options will use the default value. You can see the default values below. |
| * </div> |
| * |
| * Therefore the above can be simplified as: |
| * |
| * ```js |
| * var myModule = angular.module(...); |
| * |
| * myModule.directive('directiveName', function factory(injectables) { |
| * var directiveDefinitionObject = { |
| * link: function postLink(scope, iElement, iAttrs) { ... } |
| * }; |
| * return directiveDefinitionObject; |
| * // or |
| * // return function postLink(scope, iElement, iAttrs) { ... } |
| * }); |
| * ``` |
| * |
| * |
| * |
| * ### Directive Definition Object |
| * |
| * The directive definition object provides instructions to the {@link ng.$compile |
| * compiler}. The attributes are: |
| * |
| * #### `multiElement` |
| * When this property is set to true, the HTML compiler will collect DOM nodes between |
| * nodes with the attributes `directive-name-start` and `directive-name-end`, and group them |
| * together as the directive elements. It is recommended that this feature be used on directives |
| * which are not strictly behavioural (such as {@link ngClick}), and which |
| * do not manipulate or replace child nodes (such as {@link ngInclude}). |
| * |
| * #### `priority` |
| * When there are multiple directives defined on a single DOM element, sometimes it |
| * is necessary to specify the order in which the directives are applied. The `priority` is used |
| * to sort the directives before their `compile` functions get called. Priority is defined as a |
| * number. Directives with greater numerical `priority` are compiled first. Pre-link functions |
| * are also run in priority order, but post-link functions are run in reverse order. The order |
| * of directives with the same priority is undefined. The default priority is `0`. |
| * |
| * #### `terminal` |
| * If set to true then the current `priority` will be the last set of directives |
| * which will execute (any directives at the current priority will still execute |
| * as the order of execution on same `priority` is undefined). Note that expressions |
| * and other directives used in the directive's template will also be excluded from execution. |
| * |
| * #### `scope` |
| * The scope property can be `true`, an object or a falsy value: |
| * |
| * * **falsy:** No scope will be created for the directive. The directive will use its parent's scope. |
| * |
| * * **`true`:** A new child scope that prototypically inherits from its parent will be created for |
| * the directive's element. If multiple directives on the same element request a new scope, |
| * only one new scope is created. The new scope rule does not apply for the root of the template |
| * since the root of the template always gets a new scope. |
| * |
| * * **`{...}` (an object hash):** A new "isolate" scope is created for the directive's element. The |
| * 'isolate' scope differs from normal scope in that it does not prototypically inherit from its parent |
| * scope. This is useful when creating reusable components, which should not accidentally read or modify |
| * data in the parent scope. |
| * |
| * The 'isolate' scope object hash defines a set of local scope properties derived from attributes on the |
| * directive's element. These local properties are useful for aliasing values for templates. The keys in |
| * the object hash map to the name of the property on the isolate scope; the values define how the property |
| * is bound to the parent scope, via matching attributes on the directive's element: |
| * |
| * * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is |
| * always a string since DOM attributes are strings. If no `attr` name is specified then the |
| * attribute name is assumed to be the same as the local name. |
| * Given `<widget my-attr="hello {{name}}">` and widget definition |
| * of `scope: { localName:'@myAttr' }`, then widget scope property `localName` will reflect |
| * the interpolated value of `hello {{name}}`. As the `name` attribute changes so will the |
| * `localName` property on the widget scope. The `name` is read from the parent scope (not |
| * component scope). |
| * |
| * * `=` or `=attr` - set up bi-directional binding between a local scope property and the |
| * parent scope property of name defined via the value of the `attr` attribute. If no `attr` |
| * name is specified then the attribute name is assumed to be the same as the local name. |
| * Given `<widget my-attr="parentModel">` and widget definition of |
| * `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the |
| * value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected |
| * in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent |
| * scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You |
| * can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional. If |
| * you want to shallow watch for changes (i.e. $watchCollection instead of $watch) you can use |
| * `=*` or `=*attr` (`=*?` or `=*?attr` if the property is optional). |
| * |
| * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope. |
| * If no `attr` name is specified then the attribute name is assumed to be the same as the |
| * local name. Given `<widget my-attr="count = count + value">` and widget definition of |
| * `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to |
| * a function wrapper for the `count = count + value` expression. Often it's desirable to |
| * pass data from the isolated scope via an expression to the parent scope, this can be |
| * done by passing a map of local variable names and values into the expression wrapper fn. |
| * For example, if the expression is `increment(amount)` then we can specify the amount value |
| * by calling the `localFn` as `localFn({amount: 22})`. |
| * |
| * In general it's possible to apply more than one directive to one element, but there might be limitations |
| * depending on the type of scope required by the directives. The following points will help explain these limitations. |
| * For simplicity only two directives are taken into account, but it is also applicable for several directives: |
| * |
| * * **no scope** + **no scope** => Two directives which don't require their own scope will use their parent's scope |
| * * **child scope** + **no scope** => Both directives will share one single child scope |
| * * **child scope** + **child scope** => Both directives will share one single child scope |
| * * **isolated scope** + **no scope** => The isolated directive will use it's own created isolated scope. The other directive will use |
| * its parent's scope |
| * * **isolated scope** + **child scope** => **Won't work!** Only one scope can be related to one element. Therefore these directives cannot |
| * be applied to the same element. |
| * * **isolated scope** + **isolated scope** => **Won't work!** Only one scope can be related to one element. Therefore these directives |
| * cannot be applied to the same element. |
| * |
| * |
| * #### `bindToController` |
| * When an isolate scope is used for a component (see above), and `controllerAs` is used, `bindToController: true` will |
| * allow a component to have its properties bound to the controller, rather than to scope. When the controller |
| * is instantiated, the initial values of the isolate scope bindings are already available. |
| * |
| * #### `controller` |
| * Controller constructor function. The controller is instantiated before the |
| * pre-linking phase and can be accessed by other directives (see |
| * `require` attribute). This allows the directives to communicate with each other and augment |
| * each other's behavior. The controller is injectable (and supports bracket notation) with the following locals: |
| * |
| * * `$scope` - Current scope associated with the element |
| * * `$element` - Current element |
| * * `$attrs` - Current attributes object for the element |
| * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope: |
| * `function([scope], cloneLinkingFn, futureParentElement)`. |
| * * `scope`: optional argument to override the scope. |
| * * `cloneLinkingFn`: optional argument to create clones of the original transcluded content. |
| * * `futureParentElement`: |
| * * defines the parent to which the `cloneLinkingFn` will add the cloned elements. |
| * * default: `$element.parent()` resp. `$element` for `transclude:'element'` resp. `transclude:true`. |
| * * only needed for transcludes that are allowed to contain non html elements (e.g. SVG elements) |
| * and when the `cloneLinkinFn` is passed, |
| * as those elements need to created and cloned in a special way when they are defined outside their |
| * usual containers (e.g. like `<svg>`). |
| * * See also the `directive.templateNamespace` property. |
| * |
| * |
| * #### `require` |
| * Require another directive and inject its controller as the fourth argument to the linking function. The |
| * `require` takes a string name (or array of strings) of the directive(s) to pass in. If an array is used, the |
| * injected argument will be an array in corresponding order. If no such directive can be |
| * found, or if the directive does not have a controller, then an error is raised (unless no link function |
| * is specified, in which case error checking is skipped). The name can be prefixed with: |
| * |
| * * (no prefix) - Locate the required controller on the current element. Throw an error if not found. |
| * * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found. |
| * * `^` - Locate the required controller by searching the element and its parents. Throw an error if not found. |
| * * `^^` - Locate the required controller by searching the element's parents. Throw an error if not found. |
| * * `?^` - Attempt to locate the required controller by searching the element and its parents or pass |
| * `null` to the `link` fn if not found. |
| * * `?^^` - Attempt to locate the required controller by searching the element's parents, or pass |
| * `null` to the `link` fn if not found. |
| * |
| * |
| * #### `controllerAs` |
| * Identifier name for a reference to the controller in the directive's scope. |
| * This allows the controller to be referenced from the directive template. This is especially |
| * useful when a directive is used as component, i.e. with an `isolate` scope. It's also possible |
| * to use it in a directive without an `isolate` / `new` scope, but you need to be aware that the |
| * `controllerAs` reference might overwrite a property that already exists on the parent scope. |
| * |
| * |
| * #### `restrict` |
| * String of subset of `EACM` which restricts the directive to a specific directive |
| * declaration style. If omitted, the defaults (elements and attributes) are used. |
| * |
| * * `E` - Element name (default): `<my-directive></my-directive>` |
| * * `A` - Attribute (default): `<div my-directive="exp"></div>` |
| * * `C` - Class: `<div class="my-directive: exp;"></div>` |
| * * `M` - Comment: `<!-- directive: my-directive exp -->` |
| * |
| * |
| * #### `templateNamespace` |
| * String representing the document type used by the markup in the template. |
| * AngularJS needs this information as those elements need to be created and cloned |
| * in a special way when they are defined outside their usual containers like `<svg>` and `<math>`. |
| * |
| * * `html` - All root nodes in the template are HTML. Root nodes may also be |
| * top-level elements such as `<svg>` or `<math>`. |
| * * `svg` - The root nodes in the template are SVG elements (excluding `<math>`). |
| * * `math` - The root nodes in the template are MathML elements (excluding `<svg>`). |
| * |
| * If no `templateNamespace` is specified, then the namespace is considered to be `html`. |
| * |
| * #### `template` |
| * HTML markup that may: |
| * * Replace the contents of the directive's element (default). |
| * * Replace the directive's element itself (if `replace` is true - DEPRECATED). |
| * * Wrap the contents of the directive's element (if `transclude` is true). |
| * |
| * Value may be: |
| * |
| * * A string. For example `<div red-on-hover>{{delete_str}}</div>`. |
| * * A function which takes two arguments `tElement` and `tAttrs` (described in the `compile` |
| * function api below) and returns a string value. |
| * |
| * |
| * #### `templateUrl` |
| * This is similar to `template` but the template is loaded from the specified URL, asynchronously. |
| * |
| * Because template loading is asynchronous the compiler will suspend compilation of directives on that element |
| * for later when the template has been resolved. In the meantime it will continue to compile and link |
| * sibling and parent elements as though this element had not contained any directives. |
| * |
| * The compiler does not suspend the entire compilation to wait for templates to be loaded because this |
| * would result in the whole app "stalling" until all templates are loaded asynchronously - even in the |
| * case when only one deeply nested directive has `templateUrl`. |
| * |
| * Template loading is asynchronous even if the template has been preloaded into the {@link $templateCache} |
| * |
| * You can specify `templateUrl` as a string representing the URL or as a function which takes two |
| * arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns |
| * a string value representing the url. In either case, the template URL is passed through {@link |
| * $sce#getTrustedResourceUrl $sce.getTrustedResourceUrl}. |
| * |
| * |
| * #### `replace` ([*DEPRECATED*!], will be removed in next major release - i.e. v2.0) |
| * specify what the template should replace. Defaults to `false`. |
| * |
| * * `true` - the template will replace the directive's element. |
| * * `false` - the template will replace the contents of the directive's element. |
| * |
| * The replacement process migrates all of the attributes / classes from the old element to the new |
| * one. See the {@link guide/directive#template-expanding-directive |
| * Directives Guide} for an example. |
| * |
| * There are very few scenarios where element replacement is required for the application function, |
| * the main one being reusable custom components that are used within SVG contexts |
| * (because SVG doesn't work with custom elements in the DOM tree). |
| * |
| * #### `transclude` |
| * Extract the contents of the element where the directive appears and make it available to the directive. |
| * The contents are compiled and provided to the directive as a **transclusion function**. See the |
| * {@link $compile#transclusion Transclusion} section below. |
| * |
| * There are two kinds of transclusion depending upon whether you want to transclude just the contents of the |
| * directive's element or the entire element: |
| * |
| * * `true` - transclude the content (i.e. the child nodes) of the directive's element. |
| * * `'element'` - transclude the whole of the directive's element including any directives on this |
| * element that defined at a lower priority than this directive. When used, the `template` |
| * property is ignored. |
| * |
| * |
| * #### `compile` |
| * |
| * ```js |
| * function compile(tElement, tAttrs, transclude) { ... } |
| * ``` |
| * |
| * The compile function deals with transforming the template DOM. Since most directives do not do |
| * template transformation, it is not used often. The compile function takes the following arguments: |
| * |
| * * `tElement` - template element - The element where the directive has been declared. It is |
| * safe to do template transformation on the element and child elements only. |
| * |
| * * `tAttrs` - template attributes - Normalized list of attributes declared on this element shared |
| * between all directive compile functions. |
| * |
| * * `transclude` - [*DEPRECATED*!] A transclude linking function: `function(scope, cloneLinkingFn)` |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** The template instance and the link instance may be different objects if the template has |
| * been cloned. For this reason it is **not** safe to do anything other than DOM transformations that |
| * apply to all cloned DOM nodes within the compile function. Specifically, DOM listener registration |
| * should be done in a linking function rather than in a compile function. |
| * </div> |
| |
| * <div class="alert alert-warning"> |
| * **Note:** The compile function cannot handle directives that recursively use themselves in their |
| * own templates or compile functions. Compiling these directives results in an infinite loop and a |
| * stack overflow errors. |
| * |
| * This can be avoided by manually using $compile in the postLink function to imperatively compile |
| * a directive's template instead of relying on automatic template compilation via `template` or |
| * `templateUrl` declaration or manual compilation inside the compile function. |
| * </div> |
| * |
| * <div class="alert alert-danger"> |
| * **Note:** The `transclude` function that is passed to the compile function is deprecated, as it |
| * e.g. does not know about the right outer scope. Please use the transclude function that is passed |
| * to the link function instead. |
| * </div> |
| |
| * A compile function can have a return value which can be either a function or an object. |
| * |
| * * returning a (post-link) function - is equivalent to registering the linking function via the |
| * `link` property of the config object when the compile function is empty. |
| * |
| * * returning an object with function(s) registered via `pre` and `post` properties - allows you to |
| * control when a linking function should be called during the linking phase. See info about |
| * pre-linking and post-linking functions below. |
| * |
| * |
| * #### `link` |
| * This property is used only if the `compile` property is not defined. |
| * |
| * ```js |
| * function link(scope, iElement, iAttrs, controller, transcludeFn) { ... } |
| * ``` |
| * |
| * The link function is responsible for registering DOM listeners as well as updating the DOM. It is |
| * executed after the template has been cloned. This is where most of the directive logic will be |
| * put. |
| * |
| * * `scope` - {@link ng.$rootScope.Scope Scope} - The scope to be used by the |
| * directive for registering {@link ng.$rootScope.Scope#$watch watches}. |
| * |
| * * `iElement` - instance element - The element where the directive is to be used. It is safe to |
| * manipulate the children of the element only in `postLink` function since the children have |
| * already been linked. |
| * |
| * * `iAttrs` - instance attributes - Normalized list of attributes declared on this element shared |
| * between all directive linking functions. |
| * |
| * * `controller` - the directive's required controller instance(s) - Instances are shared |
| * among all directives, which allows the directives to use the controllers as a communication |
| * channel. The exact value depends on the directive's `require` property: |
| * * no controller(s) required: the directive's own controller, or `undefined` if it doesn't have one |
| * * `string`: the controller instance |
| * * `array`: array of controller instances |
| * |
| * If a required controller cannot be found, and it is optional, the instance is `null`, |
| * otherwise the {@link error:$compile:ctreq Missing Required Controller} error is thrown. |
| * |
| * Note that you can also require the directive's own controller - it will be made available like |
| * any other controller. |
| * |
| * * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope. |
| * This is the same as the `$transclude` |
| * parameter of directive controllers, see there for details. |
| * `function([scope], cloneLinkingFn, futureParentElement)`. |
| * |
| * #### Pre-linking function |
| * |
| * Executed before the child elements are linked. Not safe to do DOM transformation since the |
| * compiler linking function will fail to locate the correct elements for linking. |
| * |
| * #### Post-linking function |
| * |
| * Executed after the child elements are linked. |
| * |
| * Note that child elements that contain `templateUrl` directives will not have been compiled |
| * and linked since they are waiting for their template to load asynchronously and their own |
| * compilation and linking has been suspended until that occurs. |
| * |
| * It is safe to do DOM transformation in the post-linking function on elements that are not waiting |
| * for their async templates to be resolved. |
| * |
| * |
| * ### Transclusion |
| * |
| * Transclusion is the process of extracting a collection of DOM elements from one part of the DOM and |
| * copying them to another part of the DOM, while maintaining their connection to the original AngularJS |
| * scope from where they were taken. |
| * |
| * Transclusion is used (often with {@link ngTransclude}) to insert the |
| * original contents of a directive's element into a specified place in the template of the directive. |
| * The benefit of transclusion, over simply moving the DOM elements manually, is that the transcluded |
| * content has access to the properties on the scope from which it was taken, even if the directive |
| * has isolated scope. |
| * See the {@link guide/directive#creating-a-directive-that-wraps-other-elements Directives Guide}. |
| * |
| * This makes it possible for the widget to have private state for its template, while the transcluded |
| * content has access to its originating scope. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** When testing an element transclude directive you must not place the directive at the root of the |
| * DOM fragment that is being compiled. See {@link guide/unit-testing#testing-transclusion-directives |
| * Testing Transclusion Directives}. |
| * </div> |
| * |
| * #### Transclusion Functions |
| * |
| * When a directive requests transclusion, the compiler extracts its contents and provides a **transclusion |
| * function** to the directive's `link` function and `controller`. This transclusion function is a special |
| * **linking function** that will return the compiled contents linked to a new transclusion scope. |
| * |
| * <div class="alert alert-info"> |
| * If you are just using {@link ngTransclude} then you don't need to worry about this function, since |
| * ngTransclude will deal with it for us. |
| * </div> |
| * |
| * If you want to manually control the insertion and removal of the transcluded content in your directive |
| * then you must use this transclude function. When you call a transclude function it returns a a jqLite/JQuery |
| * object that contains the compiled DOM, which is linked to the correct transclusion scope. |
| * |
| * When you call a transclusion function you can pass in a **clone attach function**. This function accepts |
| * two parameters, `function(clone, scope) { ... }`, where the `clone` is a fresh compiled copy of your transcluded |
| * content and the `scope` is the newly created transclusion scope, to which the clone is bound. |
| * |
| * <div class="alert alert-info"> |
| * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a translude function |
| * since you then get a fresh clone of the original DOM and also have access to the new transclusion scope. |
| * </div> |
| * |
| * It is normal practice to attach your transcluded content (`clone`) to the DOM inside your **clone |
| * attach function**: |
| * |
| * ```js |
| * var transcludedContent, transclusionScope; |
| * |
| * $transclude(function(clone, scope) { |
| * element.append(clone); |
| * transcludedContent = clone; |
| * transclusionScope = scope; |
| * }); |
| * ``` |
| * |
| * Later, if you want to remove the transcluded content from your DOM then you should also destroy the |
| * associated transclusion scope: |
| * |
| * ```js |
| * transcludedContent.remove(); |
| * transclusionScope.$destroy(); |
| * ``` |
| * |
| * <div class="alert alert-info"> |
| * **Best Practice**: if you intend to add and remove transcluded content manually in your directive |
| * (by calling the transclude function to get the DOM and calling `element.remove()` to remove it), |
| * then you are also responsible for calling `$destroy` on the transclusion scope. |
| * </div> |
| * |
| * The built-in DOM manipulation directives, such as {@link ngIf}, {@link ngSwitch} and {@link ngRepeat} |
| * automatically destroy their transluded clones as necessary so you do not need to worry about this if |
| * you are simply using {@link ngTransclude} to inject the transclusion into your directive. |
| * |
| * |
| * #### Transclusion Scopes |
| * |
| * When you call a transclude function it returns a DOM fragment that is pre-bound to a **transclusion |
| * scope**. This scope is special, in that it is a child of the directive's scope (and so gets destroyed |
| * when the directive's scope gets destroyed) but it inherits the properties of the scope from which it |
| * was taken. |
| * |
| * For example consider a directive that uses transclusion and isolated scope. The DOM hierarchy might look |
| * like this: |
| * |
| * ```html |
| * <div ng-app> |
| * <div isolate> |
| * <div transclusion> |
| * </div> |
| * </div> |
| * </div> |
| * ``` |
| * |
| * The `$parent` scope hierarchy will look like this: |
| * |
| * ``` |
| * - $rootScope |
| * - isolate |
| * - transclusion |
| * ``` |
| * |
| * but the scopes will inherit prototypically from different scopes to their `$parent`. |
| * |
| * ``` |
| * - $rootScope |
| * - transclusion |
| * - isolate |
| * ``` |
| * |
| * |
| * ### Attributes |
| * |
| * The {@link ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the |
| * `link()` or `compile()` functions. It has a variety of uses. |
| * |
| * accessing *Normalized attribute names:* |
| * Directives like 'ngBind' can be expressed in many ways: 'ng:bind', `data-ng-bind`, or 'x-ng-bind'. |
| * the attributes object allows for normalized access to |
| * the attributes. |
| * |
| * * *Directive inter-communication:* All directives share the same instance of the attributes |
| * object which allows the directives to use the attributes object as inter directive |
| * communication. |
| * |
| * * *Supports interpolation:* Interpolation attributes are assigned to the attribute object |
| * allowing other directives to read the interpolated value. |
| * |
| * * *Observing interpolated attributes:* Use `$observe` to observe the value changes of attributes |
| * that contain interpolation (e.g. `src="{{bar}}"`). Not only is this very efficient but it's also |
| * the only way to easily get the actual value because during the linking phase the interpolation |
| * hasn't been evaluated yet and so the value is at this time set to `undefined`. |
| * |
| * ```js |
| * function linkingFn(scope, elm, attrs, ctrl) { |
| * // get the attribute value |
| * console.log(attrs.ngModel); |
| * |
| * // change the attribute |
| * attrs.$set('ngModel', 'new value'); |
| * |
| * // observe changes to interpolated attribute |
| * attrs.$observe('ngModel', function(value) { |
| * console.log('ngModel has changed value to ' + value); |
| * }); |
| * } |
| * ``` |
| * |
| * ## Example |
| * |
| * <div class="alert alert-warning"> |
| * **Note**: Typically directives are registered with `module.directive`. The example below is |
| * to illustrate how `$compile` works. |
| * </div> |
| * |
| <example module="compileExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('compileExample', [], function($compileProvider) { |
| // configure new 'compile' directive by passing a directive |
| // factory function. The factory function injects the '$compile' |
| $compileProvider.directive('compile', function($compile) { |
| // directive factory creates a link function |
| return function(scope, element, attrs) { |
| scope.$watch( |
| function(scope) { |
| // watch the 'compile' expression for changes |
| return scope.$eval(attrs.compile); |
| }, |
| function(value) { |
| // when the 'compile' expression changes |
| // assign it into the current DOM |
| element.html(value); |
| |
| // compile the new DOM and link it to the current |
| // scope. |
| // NOTE: we only compile .childNodes so that |
| // we don't get into infinite loop compiling ourselves |
| $compile(element.contents())(scope); |
| } |
| ); |
| }; |
| }); |
| }) |
| .controller('GreeterController', ['$scope', function($scope) { |
| $scope.name = 'Angular'; |
| $scope.html = 'Hello {{name}}'; |
| }]); |
| </script> |
| <div ng-controller="GreeterController"> |
| <input ng-model="name"> <br/> |
| <textarea ng-model="html"></textarea> <br/> |
| <div compile="html"></div> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should auto compile', function() { |
| var textarea = $('textarea'); |
| var output = $('div[compile]'); |
| // The initial state reads 'Hello Angular'. |
| expect(output.getText()).toBe('Hello Angular'); |
| textarea.clear(); |
| textarea.sendKeys('{{name}}!'); |
| expect(output.getText()).toBe('Angular!'); |
| }); |
| </file> |
| </example> |
| |
| * |
| * |
| * @param {string|DOMElement} element Element or HTML string to compile into a template function. |
| * @param {function(angular.Scope, cloneAttachFn=)} transclude function available to directives - DEPRECATED. |
| * |
| * <div class="alert alert-danger"> |
| * **Note:** Passing a `transclude` function to the $compile function is deprecated, as it |
| * e.g. will not use the right outer scope. Please pass the transclude function as a |
| * `parentBoundTranscludeFn` to the link function instead. |
| * </div> |
| * |
| * @param {number} maxPriority only apply directives lower than given priority (Only effects the |
| * root element(s), not their children) |
| * @returns {function(scope, cloneAttachFn=, options=)} a link function which is used to bind template |
| * (a DOM element/tree) to a scope. Where: |
| * |
| * * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to. |
| * * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the |
| * `template` and call the `cloneAttachFn` function allowing the caller to attach the |
| * cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is |
| * called as: <br/> `cloneAttachFn(clonedElement, scope)` where: |
| * |
| * * `clonedElement` - is a clone of the original `element` passed into the compiler. |
| * * `scope` - is the current scope with which the linking function is working with. |
| * |
| * * `options` - An optional object hash with linking options. If `options` is provided, then the following |
| * keys may be used to control linking behavior: |
| * |
| * * `parentBoundTranscludeFn` - the transclude function made available to |
| * directives; if given, it will be passed through to the link functions of |
| * directives found in `element` during compilation. |
| * * `transcludeControllers` - an object hash with keys that map controller names |
| * to controller instances; if given, it will make the controllers |
| * available to directives. |
| * * `futureParentElement` - defines the parent to which the `cloneAttachFn` will add |
| * the cloned elements; only needed for transcludes that are allowed to contain non html |
| * elements (e.g. SVG elements). See also the directive.controller property. |
| * |
| * Calling the linking function returns the element of the template. It is either the original |
| * element passed in, or the clone of the element if the `cloneAttachFn` is provided. |
| * |
| * After linking the view is not updated until after a call to $digest which typically is done by |
| * Angular automatically. |
| * |
| * If you need access to the bound view, there are two ways to do it: |
| * |
| * - If you are not asking the linking function to clone the template, create the DOM element(s) |
| * before you send them to the compiler and keep this reference around. |
| * ```js |
| * var element = $compile('<p>{{total}}</p>')(scope); |
| * ``` |
| * |
| * - if on the other hand, you need the element to be cloned, the view reference from the original |
| * example would not point to the clone, but rather to the original template that was cloned. In |
| * this case, you can access the clone via the cloneAttachFn: |
| * ```js |
| * var templateElement = angular.element('<p>{{total}}</p>'), |
| * scope = ....; |
| * |
| * var clonedElement = $compile(templateElement)(scope, function(clonedElement, scope) { |
| * //attach the clone to DOM document at the right place |
| * }); |
| * |
| * //now we have reference to the cloned DOM via `clonedElement` |
| * ``` |
| * |
| * |
| * For information on how the compiler works, see the |
| * {@link guide/compiler Angular HTML Compiler} section of the Developer Guide. |
| */ |
| |
| var $compileMinErr = minErr('$compile'); |
| |
| /** |
| * @ngdoc provider |
| * @name $compileProvider |
| * |
| * @description |
| */ |
| $CompileProvider.$inject = ['$provide', '$$sanitizeUriProvider']; |
| function $CompileProvider($provide, $$sanitizeUriProvider) { |
| var hasDirectives = {}, |
| Suffix = 'Directive', |
| COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\w\-]+)\s+(.*)$/, |
| CLASS_DIRECTIVE_REGEXP = /(([\w\-]+)(?:\:([^;]+))?;?)/, |
| ALL_OR_NOTHING_ATTRS = makeMap('ngSrc,ngSrcset,src,srcset'), |
| REQUIRE_PREFIX_REGEXP = /^(?:(\^\^?)?(\?)?(\^\^?)?)?/; |
| |
| // Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes |
| // The assumption is that future DOM event attribute names will begin with |
| // 'on' and be composed of only English letters. |
| var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/; |
| |
| function parseIsolateBindings(scope, directiveName, isController) { |
| var LOCAL_REGEXP = /^\s*([@&]|=(\*?))(\??)\s*(\w*)\s*$/; |
| |
| var bindings = {}; |
| |
| forEach(scope, function(definition, scopeName) { |
| var match = definition.match(LOCAL_REGEXP); |
| |
| if (!match) { |
| throw $compileMinErr('iscp', |
| "Invalid {3} for directive '{0}'." + |
| " Definition: {... {1}: '{2}' ...}", |
| directiveName, scopeName, definition, |
| (isController ? "controller bindings definition" : |
| "isolate scope definition")); |
| } |
| |
| bindings[scopeName] = { |
| mode: match[1][0], |
| collection: match[2] === '*', |
| optional: match[3] === '?', |
| attrName: match[4] || scopeName |
| }; |
| }); |
| |
| return bindings; |
| } |
| |
| function parseDirectiveBindings(directive, directiveName) { |
| var bindings = { |
| isolateScope: null, |
| bindToController: null |
| }; |
| if (isObject(directive.scope)) { |
| if (directive.bindToController === true) { |
| bindings.bindToController = parseIsolateBindings(directive.scope, |
| directiveName, true); |
| bindings.isolateScope = {}; |
| } else { |
| bindings.isolateScope = parseIsolateBindings(directive.scope, |
| directiveName, false); |
| } |
| } |
| if (isObject(directive.bindToController)) { |
| bindings.bindToController = |
| parseIsolateBindings(directive.bindToController, directiveName, true); |
| } |
| if (isObject(bindings.bindToController)) { |
| var controller = directive.controller; |
| var controllerAs = directive.controllerAs; |
| if (!controller) { |
| // There is no controller, there may or may not be a controllerAs property |
| throw $compileMinErr('noctrl', |
| "Cannot bind to controller without directive '{0}'s controller.", |
| directiveName); |
| } else if (!identifierForController(controller, controllerAs)) { |
| // There is a controller, but no identifier or controllerAs property |
| throw $compileMinErr('noident', |
| "Cannot bind to controller without identifier for directive '{0}'.", |
| directiveName); |
| } |
| } |
| return bindings; |
| } |
| |
| function assertValidDirectiveName(name) { |
| var letter = name.charAt(0); |
| if (!letter || letter !== lowercase(letter)) { |
| throw $compileMinErr('baddir', "Directive name '{0}' is invalid. The first character must be a lowercase letter", name); |
| } |
| if (name !== name.trim()) { |
| throw $compileMinErr('baddir', |
| "Directive name '{0}' is invalid. The name should not contain leading or trailing whitespaces", |
| name); |
| } |
| } |
| |
| /** |
| * @ngdoc method |
| * @name $compileProvider#directive |
| * @kind function |
| * |
| * @description |
| * Register a new directive with the compiler. |
| * |
| * @param {string|Object} name Name of the directive in camel-case (i.e. <code>ngBind</code> which |
| * will match as <code>ng-bind</code>), or an object map of directives where the keys are the |
| * names and the values are the factories. |
| * @param {Function|Array} directiveFactory An injectable directive factory function. See |
| * {@link guide/directive} for more info. |
| * @returns {ng.$compileProvider} Self for chaining. |
| */ |
| this.directive = function registerDirective(name, directiveFactory) { |
| assertNotHasOwnProperty(name, 'directive'); |
| if (isString(name)) { |
| assertValidDirectiveName(name); |
| assertArg(directiveFactory, 'directiveFactory'); |
| if (!hasDirectives.hasOwnProperty(name)) { |
| hasDirectives[name] = []; |
| $provide.factory(name + Suffix, ['$injector', '$exceptionHandler', |
| function($injector, $exceptionHandler) { |
| var directives = []; |
| forEach(hasDirectives[name], function(directiveFactory, index) { |
| try { |
| var directive = $injector.invoke(directiveFactory); |
| if (isFunction(directive)) { |
| directive = { compile: valueFn(directive) }; |
| } else if (!directive.compile && directive.link) { |
| directive.compile = valueFn(directive.link); |
| } |
| directive.priority = directive.priority || 0; |
| directive.index = index; |
| directive.name = directive.name || name; |
| directive.require = directive.require || (directive.controller && directive.name); |
| directive.restrict = directive.restrict || 'EA'; |
| var bindings = directive.$$bindings = |
| parseDirectiveBindings(directive, directive.name); |
| if (isObject(bindings.isolateScope)) { |
| directive.$$isolateBindings = bindings.isolateScope; |
| } |
| directive.$$moduleName = directiveFactory.$$moduleName; |
| directives.push(directive); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| }); |
| return directives; |
| }]); |
| } |
| hasDirectives[name].push(directiveFactory); |
| } else { |
| forEach(name, reverseParams(registerDirective)); |
| } |
| return this; |
| }; |
| |
| |
| /** |
| * @ngdoc method |
| * @name $compileProvider#aHrefSanitizationWhitelist |
| * @kind function |
| * |
| * @description |
| * Retrieves or overrides the default regular expression that is used for whitelisting of safe |
| * urls during a[href] sanitization. |
| * |
| * The sanitization is a security measure aimed at preventing XSS attacks via html links. |
| * |
| * Any url about to be assigned to a[href] via data-binding is first normalized and turned into |
| * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist` |
| * regular expression. If a match is found, the original url is written into the dom. Otherwise, |
| * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM. |
| * |
| * @param {RegExp=} regexp New regexp to whitelist urls with. |
| * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for |
| * chaining otherwise. |
| */ |
| this.aHrefSanitizationWhitelist = function(regexp) { |
| if (isDefined(regexp)) { |
| $$sanitizeUriProvider.aHrefSanitizationWhitelist(regexp); |
| return this; |
| } else { |
| return $$sanitizeUriProvider.aHrefSanitizationWhitelist(); |
| } |
| }; |
| |
| |
| /** |
| * @ngdoc method |
| * @name $compileProvider#imgSrcSanitizationWhitelist |
| * @kind function |
| * |
| * @description |
| * Retrieves or overrides the default regular expression that is used for whitelisting of safe |
| * urls during img[src] sanitization. |
| * |
| * The sanitization is a security measure aimed at prevent XSS attacks via html links. |
| * |
| * Any url about to be assigned to img[src] via data-binding is first normalized and turned into |
| * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist` |
| * regular expression. If a match is found, the original url is written into the dom. Otherwise, |
| * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM. |
| * |
| * @param {RegExp=} regexp New regexp to whitelist urls with. |
| * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for |
| * chaining otherwise. |
| */ |
| this.imgSrcSanitizationWhitelist = function(regexp) { |
| if (isDefined(regexp)) { |
| $$sanitizeUriProvider.imgSrcSanitizationWhitelist(regexp); |
| return this; |
| } else { |
| return $$sanitizeUriProvider.imgSrcSanitizationWhitelist(); |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $compileProvider#debugInfoEnabled |
| * |
| * @param {boolean=} enabled update the debugInfoEnabled state if provided, otherwise just return the |
| * current debugInfoEnabled state |
| * @returns {*} current value if used as getter or itself (chaining) if used as setter |
| * |
| * @kind function |
| * |
| * @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 |
| * * `$binding` data property containing an array of the binding expressions |
| * |
| * 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; |
| }; |
| |
| this.$get = [ |
| '$injector', '$interpolate', '$exceptionHandler', '$templateRequest', '$parse', |
| '$controller', '$rootScope', '$document', '$sce', '$animate', '$$sanitizeUri', |
| function($injector, $interpolate, $exceptionHandler, $templateRequest, $parse, |
| $controller, $rootScope, $document, $sce, $animate, $$sanitizeUri) { |
| |
| var Attributes = function(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') || |
| (nodeName === 'img' && key === 'src')) { |
| // sanitize a[href] and img[src] values |
| this[key] = value = $$sanitizeUri(value, key === 'src'); |
| } else if (nodeName === 'img' && key === 'srcset') { |
| // 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 { |
| this.$$element.attr(attrName, value); |
| } |
| } |
| |
| // fire observers |
| var $$observers = this.$$observers; |
| $$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/directive#text-and-attribute-bindings Directives} 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 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]/; |
| |
| compile.$$addBindingInfo = debugInfoEnabled ? function $$addBindingInfo($element, binding) { |
| var bindings = $element.data('$binding') || []; |
| |
| if (isArray(binding)) { |
| bindings = bindings.concat(binding); |
| } else { |
| bindings.push(binding); |
| } |
| |
| $element.data('$binding', bindings); |
| } : noop; |
| |
| compile.$$addBindingClass = debugInfoEnabled ? function $$addBindingClass($element) { |
| safeAddClass($element, 'ng-binding'); |
| } : noop; |
| |
| compile.$$addScopeInfo = debugInfoEnabled ? function $$addScopeInfo($element, scope, isolated, noTemplate) { |
| var dataName = isolated ? (noTemplate ? '$isolateScopeNoTemplate' : '$isolateScope') : '$scope'; |
| $element.data(dataName, scope); |
| } : noop; |
| |
| compile.$$addScopeClass = debugInfoEnabled ? function $$addScopeClass($element, isolated) { |
| safeAddClass($element, isolated ? 'ng-isolate-scope' : 'ng-scope'); |
| } : noop; |
| |
| return compile; |
| |
| //================================ |
| |
| function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, |
| previousCompileContext) { |
| if (!($compileNodes instanceof jqLite)) { |
| // jquery always rewraps, whereas we need to preserve the original selector so that we can |
| // modify it. |
| $compileNodes = jqLite($compileNodes); |
| } |
| // We can not compile top level text elements since text nodes can be merged and we will |
| // not be able to attach scope data to them, so we will wrap them in <span> |
| forEach($compileNodes, function(node, index) { |
| if (node.nodeType == NODE_TYPE_TEXT && node.nodeValue.match(/\S+/) /* non-empty */ ) { |
| $compileNodes[index] = jqLite(node).wrap('<span></span>').parent()[0]; |
| } |
| }); |
| var compositeLinkFn = |
| compileNodes($compileNodes, transcludeFn, $compileNodes, |
| maxPriority, ignoreDirective, previousCompileContext); |
| compile.$$addScopeClass($compileNodes); |
| var namespace = null; |
| return function publicLinkFn(scope, cloneConnectFn, options) { |
| assertArg(scope, 'scope'); |
| |
| options = options || {}; |
| var parentBoundTranscludeFn = options.parentBoundTranscludeFn, |
| transcludeControllers = options.transcludeControllers, |
| futureParentElement = options.futureParentElement; |
| |
| // When `parentBoundTranscludeFn` is passed, it is a |
| // `controllersBoundTransclude` function (it was previously passed |
| // as `transclude` to directive.link) so we must unwrap it to get |
| // its `boundTranscludeFn` |
| if (parentBoundTranscludeFn && parentBoundTranscludeFn.$$boundTransclude) { |
| parentBoundTranscludeFn = parentBoundTranscludeFn.$$boundTransclude; |
| } |
| |
| if (!namespace) { |
| namespace = detectNamespaceForChildElements(futureParentElement); |
| } |
| var $linkNode; |
| if (namespace !== 'html') { |
| // When using a directive with replace:true and templateUrl the $compileNodes |
| // (or a child element inside of them) |
| // might change, so we need to recreate the namespace adapted compileNodes |
| // for call to the link function. |
| // Note: This will already clone the nodes... |
| $linkNode = jqLite( |
| wrapTemplate(namespace, jqLite('<div>').append($compileNodes).html()) |
| ); |
| } else if (cloneConnectFn) { |
| // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart |
| // and sometimes changes the structure of the DOM. |
| $linkNode = JQLitePrototype.clone.call($compileNodes); |
| } else { |
| $linkNode = $compileNodes; |
| } |
| |
| if (transcludeControllers) { |
| for (var controllerName in transcludeControllers) { |
| $linkNode.data('$' + controllerName + 'Controller', transcludeControllers[controllerName].instance); |
| } |
| } |
| |
| compile.$$addScopeInfo($linkNode, scope); |
| |
| if (cloneConnectFn) cloneConnectFn($linkNode, scope); |
| if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode, parentBoundTranscludeFn); |
| return $linkNode; |
| }; |
| } |
| |
| function detectNamespaceForChildElements(parentElement) { |
| // TODO: Make this detect MathML as well... |
| var node = parentElement && parentElement[0]; |
| if (!node) { |
| return 'html'; |
| } else { |
| return nodeName_(node) !== 'foreignobject' && node.toString().match(/SVG/) ? 'svg' : 'html'; |
| } |
| } |
| |
| /** |
| * Compile function matches each node in nodeList against the directives. Once all directives |
| * for a particular node are collected their compile functions are executed. The compile |
| * functions return values - the linking functions - are combined into a composite linking |
| * function, which is the a linking function for the node. |
| * |
| * @param {NodeList} nodeList an array of nodes or NodeList to compile |
| * @param {function(angular.Scope, cloneAttachFn=)} transcludeFn A linking function, where the |
| * scope argument is auto-generated to the new child of the transcluded parent scope. |
| * @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then |
| * the rootElement must be set the jqLite collection of the compile root. This is |
| * needed so that the jqLite collection items can be replaced with widgets. |
| * @param {number=} maxPriority Max directive priority. |
| * @returns {Function} A composite linking function of all of the matched directives or null. |
| */ |
| function compileNodes(nodeList, transcludeFn, $rootElement, maxPriority, ignoreDirective, |
| previousCompileContext) { |
| var linkFns = [], |
| attrs, directives, nodeLinkFn, childNodes, childLinkFn, linkFnFound, nodeLinkFnFound; |
| |
| for (var i = 0; i < nodeList.length; i++) { |
| attrs = new Attributes(); |
| |
| // we must always refer to nodeList[i] since the nodes can be replaced underneath us. |
| directives = collectDirectives(nodeList[i], [], attrs, i === 0 ? maxPriority : undefined, |
| ignoreDirective); |
| |
| nodeLinkFn = (directives.length) |
| ? applyDirectivesToNode(directives, nodeList[i], attrs, transcludeFn, $rootElement, |
| null, [], [], previousCompileContext) |
| : null; |
| |
| if (nodeLinkFn && nodeLinkFn.scope) { |
| compile.$$addScopeClass(attrs.$$element); |
| } |
| |
| childLinkFn = (nodeLinkFn && nodeLinkFn.terminal || |
| !(childNodes = nodeList[i].childNodes) || |
| !childNodes.length) |
| ? null |
| : compileNodes(childNodes, |
| nodeLinkFn ? ( |
| (nodeLinkFn.transcludeOnThisElement || !nodeLinkFn.templateOnThisElement) |
| && nodeLinkFn.transclude) : transcludeFn); |
| |
| if (nodeLinkFn || childLinkFn) { |
| linkFns.push(i, nodeLinkFn, childLinkFn); |
| linkFnFound = true; |
| nodeLinkFnFound = nodeLinkFnFound || nodeLinkFn; |
| } |
| |
| //use the previous context only for the first element in the virtual group |
| previousCompileContext = null; |
| } |
| |
| // return a linking function if we have found anything, null otherwise |
| return linkFnFound ? compositeLinkFn : null; |
| |
| function compositeLinkFn(scope, nodeList, $rootElement, parentBoundTranscludeFn) { |
| var nodeLinkFn, childLinkFn, node, childScope, i, ii, idx, childBoundTranscludeFn; |
| var stableNodeList; |
| |
| |
| if (nodeLinkFnFound) { |
| // copy nodeList so that if a nodeLinkFn removes or adds an element at this DOM level our |
| // offsets don't get screwed up |
| var nodeListLength = nodeList.length; |
| stableNodeList = new Array(nodeListLength); |
| |
| // create a sparse array by only copying the elements which have a linkFn |
| for (i = 0; i < linkFns.length; i+=3) { |
| idx = linkFns[i]; |
| stableNodeList[idx] = nodeList[idx]; |
| } |
| } else { |
| stableNodeList = nodeList; |
| } |
| |
| for (i = 0, ii = linkFns.length; i < ii;) { |
| node = stableNodeList[linkFns[i++]]; |
| nodeLinkFn = linkFns[i++]; |
| childLinkFn = linkFns[i++]; |
| |
| if (nodeLinkFn) { |
| if (nodeLinkFn.scope) { |
| childScope = scope.$new(); |
| compile.$$addScopeInfo(jqLite(node), childScope); |
| var destroyBindings = nodeLinkFn.$$destroyBindings; |
| if (destroyBindings) { |
| nodeLinkFn.$$destroyBindings = null; |
| childScope.$on('$destroyed', destroyBindings); |
| } |
| } else { |
| childScope = scope; |
| } |
| |
| if (nodeLinkFn.transcludeOnThisElement) { |
| childBoundTranscludeFn = createBoundTranscludeFn( |
| scope, nodeLinkFn.transclude, parentBoundTranscludeFn); |
| |
| } else if (!nodeLinkFn.templateOnThisElement && parentBoundTranscludeFn) { |
| childBoundTranscludeFn = parentBoundTranscludeFn; |
| |
| } else if (!parentBoundTranscludeFn && transcludeFn) { |
| childBoundTranscludeFn = createBoundTranscludeFn(scope, transcludeFn); |
| |
| } else { |
| childBoundTranscludeFn = null; |
| } |
| |
| nodeLinkFn(childLinkFn, childScope, node, $rootElement, childBoundTranscludeFn, |
| nodeLinkFn); |
| |
| } else if (childLinkFn) { |
| childLinkFn(scope, node.childNodes, undefined, parentBoundTranscludeFn); |
| } |
| } |
| } |
| } |
| |
| function createBoundTranscludeFn(scope, transcludeFn, previousBoundTranscludeFn) { |
| |
| var boundTranscludeFn = function(transcludedScope, cloneFn, controllers, futureParentElement, containingScope) { |
| |
| if (!transcludedScope) { |
| transcludedScope = scope.$new(false, containingScope); |
| transcludedScope.$$transcluded = true; |
| } |
| |
| return transcludeFn(transcludedScope, cloneFn, { |
| parentBoundTranscludeFn: previousBoundTranscludeFn, |
| transcludeControllers: controllers, |
| futureParentElement: futureParentElement |
| }); |
| }; |
| |
| return boundTranscludeFn; |
| } |
| |
| /** |
| * Looks for directives on the given node and adds them to the directive collection which is |
| * sorted. |
| * |
| * @param node Node to search. |
| * @param directives An array to which the directives are added to. This array is sorted before |
| * the function returns. |
| * @param attrs The shared attrs object which is used to populate the normalized attributes. |
| * @param {number=} maxPriority Max directive priority. |
| */ |
| function collectDirectives(node, directives, attrs, maxPriority, ignoreDirective) { |
| var nodeType = node.nodeType, |
| attrsMap = attrs.$attr, |
| match, |
| className; |
| |
| switch (nodeType) { |
| case NODE_TYPE_ELEMENT: /* Element */ |
| // use the node name: <directive> |
| addDirective(directives, |
| directiveNormalize(nodeName_(node)), 'E', maxPriority, ignoreDirective); |
| |
| // iterate over the attributes |
| for (var attr, name, nName, ngAttrName, value, isNgAttr, nAttrs = node.attributes, |
| j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) { |
| var attrStartName = false; |
| var attrEndName = false; |
| |
| attr = nAttrs[j]; |
| name = attr.name; |
| value = trim(attr.value); |
| |
| // support ngAttr attribute binding |
| ngAttrName = directiveNormalize(name); |
| if (isNgAttr = NG_ATTR_BINDING.test(ngAttrName)) { |
| name = name.replace(PREFIX_REGEXP, '') |
| .substr(8).replace(/_(.)/g, function(match, letter) { |
| return letter.toUpperCase(); |
| }); |
| } |
| |
| var directiveNName = ngAttrName.replace(/(Start|End)$/, ''); |
| if (directiveIsMultiElement(directiveNName)) { |
| if (ngAttrName === directiveNName + 'Start') { |
| attrStartName = name; |
| attrEndName = name.substr(0, name.length - 5) + 'end'; |
| name = name.substr(0, name.length - 6); |
| } |
| } |
| |
| nName = directiveNormalize(name.toLowerCase()); |
| attrsMap[nName] = name; |
| if (isNgAttr || !attrs.hasOwnProperty(nName)) { |
| attrs[nName] = value; |
| if (getBooleanAttrName(node, nName)) { |
| attrs[nName] = true; // presence means true |
| } |
| } |
| addAttrInterpolateDirective(node, directives, value, nName, isNgAttr); |
| addDirective(directives, nName, 'A', maxPriority, ignoreDirective, attrStartName, |
| attrEndName); |
| } |
| |
| // use class as directive |
| className = node.className; |
| if (isObject(className)) { |
| // Maybe SVGAnimatedString |
| className = className.animVal; |
| } |
| if (isString(className) && className !== '') { |
| while (match = CLASS_DIRECTIVE_REGEXP.exec(className)) { |
| nName = directiveNormalize(match[2]); |
| if (addDirective(directives, nName, 'C', maxPriority, ignoreDirective)) { |
| attrs[nName] = trim(match[3]); |
| } |
| className = className.substr(match.index + match[0].length); |
| } |
| } |
| break; |
| case NODE_TYPE_TEXT: /* Text Node */ |
| if (msie === 11) { |
| // Workaround for #11781 |
| while (node.parentNode && node.nextSibling && node.nextSibling.nodeType === NODE_TYPE_TEXT) { |
| node.nodeValue = node.nodeValue + node.nextSibling.nodeValue; |
| node.parentNode.removeChild(node.nextSibling); |
| } |
| } |
| addTextInterpolateDirective(directives, node.nodeValue); |
| break; |
| case NODE_TYPE_COMMENT: /* Comment */ |
| try { |
| match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue); |
| if (match) { |
| nName = directiveNormalize(match[1]); |
| if (addDirective(directives, nName, 'M', maxPriority, ignoreDirective)) { |
| attrs[nName] = trim(match[2]); |
| } |
| } |
| } catch (e) { |
| // turns out that under some circumstances IE9 throws errors when one attempts to read |
| // comment's node value. |
| // Just ignore it and continue. (Can't seem to reproduce in test case.) |
| } |
| break; |
| } |
| |
| directives.sort(byPriority); |
| return directives; |
| } |
| |
| /** |
| * Given a node with an directive-start it collects all of the siblings until it finds |
| * directive-end. |
| * @param node |
| * @param attrStart |
| * @param attrEnd |
| * @returns {*} |
| */ |
| function groupScan(node, attrStart, attrEnd) { |
| var nodes = []; |
| var depth = 0; |
| if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) { |
| do { |
| if (!node) { |
| throw $compileMinErr('uterdir', |
| "Unterminated attribute, found '{0}' but no matching '{1}' found.", |
| attrStart, attrEnd); |
| } |
| if (node.nodeType == NODE_TYPE_ELEMENT) { |
| if (node.hasAttribute(attrStart)) depth++; |
| if (node.hasAttribute(attrEnd)) depth--; |
| } |
| nodes.push(node); |
| node = node.nextSibling; |
| } while (depth > 0); |
| } else { |
| nodes.push(node); |
| } |
| |
| return jqLite(nodes); |
| } |
| |
| /** |
| * Wrapper for linking function which converts normal linking function into a grouped |
| * linking function. |
| * @param linkFn |
| * @param attrStart |
| * @param attrEnd |
| * @returns {Function} |
| */ |
| function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) { |
| return function(scope, element, attrs, controllers, transcludeFn) { |
| element = groupScan(element[0], attrStart, attrEnd); |
| return linkFn(scope, element, attrs, controllers, transcludeFn); |
| }; |
| } |
| |
| /** |
| * Once the directives have been collected, their compile functions are executed. This method |
| * is responsible for inlining directive templates as well as terminating the application |
| * of the directives if the terminal directive has been reached. |
| * |
| * @param {Array} directives Array of collected directives to execute their compile function. |
| * this needs to be pre-sorted by priority order. |
| * @param {Node} compileNode The raw DOM node to apply the compile functions to |
| * @param {Object} templateAttrs The shared attribute function |
| * @param {function(angular.Scope, cloneAttachFn=)} transcludeFn A linking function, where the |
| * scope argument is auto-generated to the new |
| * child of the transcluded parent scope. |
| * @param {JQLite} jqCollection If we are working on the root of the compile tree then this |
| * argument has the root jqLite array so that we can replace nodes |
| * on it. |
| * @param {Object=} originalReplaceDirective An optional directive that will be ignored when |
| * compiling the transclusion. |
| * @param {Array.<Function>} preLinkFns |
| * @param {Array.<Function>} postLinkFns |
| * @param {Object} previousCompileContext Context used for previous compilation of the current |
| * node |
| * @returns {Function} linkFn |
| */ |
| function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn, |
| jqCollection, originalReplaceDirective, preLinkFns, postLinkFns, |
| previousCompileContext) { |
| previousCompileContext = previousCompileContext || {}; |
| |
| var terminalPriority = -Number.MAX_VALUE, |
| newScopeDirective = previousCompileContext.newScopeDirective, |
| controllerDirectives = previousCompileContext.controllerDirectives, |
| newIsolateScopeDirective = previousCompileContext.newIsolateScopeDirective, |
| templateDirective = previousCompileContext.templateDirective, |
| nonTlbTranscludeDirective = previousCompileContext.nonTlbTranscludeDirective, |
| hasTranscludeDirective = false, |
| hasTemplate = false, |
| hasElementTranscludeDirective = previousCompileContext.hasElementTranscludeDirective, |
| $compileNode = templateAttrs.$$element = jqLite(compileNode), |
| directive, |
| directiveName, |
| $template, |
| replaceDirective = originalReplaceDirective, |
| childTranscludeFn = transcludeFn, |
| linkFn, |
| directiveValue; |
| |
| // executes all directives on the current element |
| for (var i = 0, ii = directives.length; i < ii; i++) { |
| directive = directives[i]; |
| var attrStart = directive.$$start; |
| var attrEnd = directive.$$end; |
| |
| // collect multiblock sections |
| if (attrStart) { |
| $compileNode = groupScan(compileNode, attrStart, attrEnd); |
| } |
| $template = undefined; |
| |
| if (terminalPriority > directive.priority) { |
| break; // prevent further processing of directives |
| } |
| |
| if (directiveValue = directive.scope) { |
| |
| // skip the check for directives with async templates, we'll check the derived sync |
| // directive when the template arrives |
| if (!directive.templateUrl) { |
| if (isObject(directiveValue)) { |
| // This directive is trying to add an isolated scope. |
| // Check that there is no scope of any kind already |
| assertNoDuplicate('new/isolated scope', newIsolateScopeDirective || newScopeDirective, |
| directive, $compileNode); |
| newIsolateScopeDirective = directive; |
| } else { |
| // This directive is trying to add a child scope. |
| // Check that there is no isolated scope already |
| assertNoDuplicate('new/isolated scope', newIsolateScopeDirective, directive, |
| $compileNode); |
| } |
| } |
| |
| newScopeDirective = newScopeDirective || directive; |
| } |
| |
| directiveName = directive.name; |
| |
| if (!directive.templateUrl && directive.controller) { |
| directiveValue = directive.controller; |
| controllerDirectives = controllerDirectives || createMap(); |
| assertNoDuplicate("'" + directiveName + "' controller", |
| controllerDirectives[directiveName], directive, $compileNode); |
| controllerDirectives[directiveName] = directive; |
| } |
| |
| if (directiveValue = directive.transclude) { |
| hasTranscludeDirective = true; |
| |
| // Special case ngIf and ngRepeat so that we don't complain about duplicate transclusion. |
| // This option should only be used by directives that know how to safely handle element transclusion, |
| // where the transcluded nodes are added or replaced after linking. |
| if (!directive.$$tlb) { |
| assertNoDuplicate('transclusion', nonTlbTranscludeDirective, directive, $compileNode); |
| nonTlbTranscludeDirective = directive; |
| } |
| |
| if (directiveValue == 'element') { |
| hasElementTranscludeDirective = true; |
| terminalPriority = directive.priority; |
| $template = $compileNode; |
| $compileNode = templateAttrs.$$element = |
| jqLite(document.createComment(' ' + directiveName + ': ' + |
| templateAttrs[directiveName] + ' ')); |
| compileNode = $compileNode[0]; |
| replaceWith(jqCollection, sliceArgs($template), compileNode); |
| |
| childTranscludeFn = compile($template, transcludeFn, terminalPriority, |
| replaceDirective && replaceDirective.name, { |
| // Don't pass in: |
| // - controllerDirectives - otherwise we'll create duplicates controllers |
| // - newIsolateScopeDirective or templateDirective - combining templates with |
| // element transclusion doesn't make sense. |
| // |
| // We need only nonTlbTranscludeDirective so that we prevent putting transclusion |
| // on the same element more than once. |
| nonTlbTranscludeDirective: nonTlbTranscludeDirective |
| }); |
| } else { |
| $template = jqLite(jqLiteClone(compileNode)).contents(); |
| $compileNode.empty(); // clear contents |
| childTranscludeFn = compile($template, transcludeFn); |
| } |
| } |
| |
| if (directive.template) { |
| hasTemplate = true; |
| assertNoDuplicate('template', templateDirective, directive, $compileNode); |
| templateDirective = directive; |
| |
| directiveValue = (isFunction(directive.template)) |
| ? directive.template($compileNode, templateAttrs) |
| : directive.template; |
| |
| directiveValue = denormalizeTemplate(directiveValue); |
| |
| if (directive.replace) { |
| replaceDirective = directive; |
| if (jqLiteIsTextNode(directiveValue)) { |
| $template = []; |
| } else { |
| $template = removeComments(wrapTemplate(directive.templateNamespace, trim(directiveValue))); |
| } |
| compileNode = $template[0]; |
| |
| if ($template.length != 1 || compileNode.nodeType !== NODE_TYPE_ELEMENT) { |
| throw $compileMinErr('tplrt', |
| "Template for directive '{0}' must have exactly one root element. {1}", |
| directiveName, ''); |
| } |
| |
| replaceWith(jqCollection, $compileNode, compileNode); |
| |
| var newTemplateAttrs = {$attr: {}}; |
| |
| // combine directives from the original node and from the template: |
| // - take the array of directives for this element |
| // - split it into two parts, those that already applied (processed) and those that weren't (unprocessed) |
| // - collect directives from the template and sort them by priority |
| // - combine directives as: processed + template + unprocessed |
| var templateDirectives = collectDirectives(compileNode, [], newTemplateAttrs); |
| var unprocessedDirectives = directives.splice(i + 1, directives.length - (i + 1)); |
| |
| if (newIsolateScopeDirective) { |
| markDirectivesAsIsolate(templateDirectives); |
| } |
| directives = directives.concat(templateDirectives).concat(unprocessedDirectives); |
| mergeTemplateAttributes(templateAttrs, newTemplateAttrs); |
| |
| ii = directives.length; |
| } else { |
| $compileNode.html(directiveValue); |
| } |
| } |
| |
| if (directive.templateUrl) { |
| hasTemplate = true; |
| assertNoDuplicate('template', templateDirective, directive, $compileNode); |
| templateDirective = directive; |
| |
| if (directive.replace) { |
| replaceDirective = directive; |
| } |
| |
| nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i), $compileNode, |
| templateAttrs, jqCollection, hasTranscludeDirective && childTranscludeFn, preLinkFns, postLinkFns, { |
| controllerDirectives: controllerDirectives, |
| newScopeDirective: (newScopeDirective !== directive) && newScopeDirective, |
| newIsolateScopeDirective: newIsolateScopeDirective, |
| templateDirective: templateDirective, |
| nonTlbTranscludeDirective: nonTlbTranscludeDirective |
| }); |
| ii = directives.length; |
| } else if (directive.compile) { |
| try { |
| linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn); |
| if (isFunction(linkFn)) { |
| addLinkFns(null, linkFn, attrStart, attrEnd); |
| } else if (linkFn) { |
| addLinkFns(linkFn.pre, linkFn.post, attrStart, attrEnd); |
| } |
| } catch (e) { |
| $exceptionHandler(e, startingTag($compileNode)); |
| } |
| } |
| |
| if (directive.terminal) { |
| nodeLinkFn.terminal = true; |
| terminalPriority = Math.max(terminalPriority, directive.priority); |
| } |
| |
| } |
| |
| nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope === true; |
| nodeLinkFn.transcludeOnThisElement = hasTranscludeDirective; |
| nodeLinkFn.templateOnThisElement = hasTemplate; |
| nodeLinkFn.transclude = childTranscludeFn; |
| |
| previousCompileContext.hasElementTranscludeDirective = hasElementTranscludeDirective; |
| |
| // might be normal or delayed nodeLinkFn depending on if templateUrl is present |
| return nodeLinkFn; |
| |
| //////////////////// |
| |
| function addLinkFns(pre, post, attrStart, attrEnd) { |
| if (pre) { |
| if (attrStart) pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd); |
| pre.require = directive.require; |
| pre.directiveName = directiveName; |
| if (newIsolateScopeDirective === directive || directive.$$isolateScope) { |
| pre = cloneAndAnnotateFn(pre, {isolateScope: true}); |
| } |
| preLinkFns.push(pre); |
| } |
| if (post) { |
| if (attrStart) post = groupElementsLinkFnWrapper(post, attrStart, attrEnd); |
| post.require = directive.require; |
| post.directiveName = directiveName; |
| if (newIsolateScopeDirective === directive || directive.$$isolateScope) { |
| post = cloneAndAnnotateFn(post, {isolateScope: true}); |
| } |
| postLinkFns.push(post); |
| } |
| } |
| |
| |
| function getControllers(directiveName, require, $element, elementControllers) { |
| var value; |
| |
| if (isString(require)) { |
| var match = require.match(REQUIRE_PREFIX_REGEXP); |
| var name = require.substring(match[0].length); |
| var inheritType = match[1] || match[3]; |
| var optional = match[2] === '?'; |
| |
| //If only parents then start at the parent element |
| if (inheritType === '^^') { |
| $element = $element.parent(); |
| //Otherwise attempt getting the controller from elementControllers in case |
| //the element is transcluded (and has no data) and to avoid .data if possible |
| } else { |
| value = elementControllers && elementControllers[name]; |
| value = value && value.instance; |
| } |
| |
| if (!value) { |
| var dataName = '$' + name + 'Controller'; |
| value = inheritType ? $element.inheritedData(dataName) : $element.data(dataName); |
| } |
| |
| if (!value && !optional) { |
| throw $compileMinErr('ctreq', |
| "Controller '{0}', required by directive '{1}', can't be found!", |
| name, directiveName); |
| } |
| } else if (isArray(require)) { |
| value = []; |
| for (var i = 0, ii = require.length; i < ii; i++) { |
| value[i] = getControllers(directiveName, require[i], $element, elementControllers); |
| } |
| } |
| |
| return value || null; |
| } |
| |
| function setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope) { |
| var elementControllers = createMap(); |
| for (var controllerKey in controllerDirectives) { |
| var directive = controllerDirectives[controllerKey]; |
| var locals = { |
| $scope: directive === newIsolateScopeDirective || directive.$$isolateScope ? isolateScope : scope, |
| $element: $element, |
| $attrs: attrs, |
| $transclude: transcludeFn |
| }; |
| |
| var controller = directive.controller; |
| if (controller == '@') { |
| controller = attrs[directive.name]; |
| } |
| |
| var controllerInstance = $controller(controller, locals, true, directive.controllerAs); |
| |
| // For directives with element transclusion the element is a comment, |
| // but jQuery .data doesn't support attaching data to comment nodes as it's hard to |
| // clean up (http://bugs.jquery.com/ticket/8335). |
| // Instead, we save the controllers for the element in a local hash and attach to .data |
| // later, once we have the actual element. |
| elementControllers[directive.name] = controllerInstance; |
| if (!hasElementTranscludeDirective) { |
| $element.data('$' + directive.name + 'Controller', controllerInstance.instance); |
| } |
| } |
| return elementControllers; |
| } |
| |
| function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn, |
| thisLinkFn) { |
| var i, ii, linkFn, controller, isolateScope, elementControllers, transcludeFn, $element, |
| attrs; |
| |
| if (compileNode === linkNode) { |
| attrs = templateAttrs; |
| $element = templateAttrs.$$element; |
| } else { |
| $element = jqLite(linkNode); |
| attrs = new Attributes($element, templateAttrs); |
| } |
| |
| if (newIsolateScopeDirective) { |
| isolateScope = scope.$new(true); |
| } |
| |
| if (boundTranscludeFn) { |
| // track `boundTranscludeFn` so it can be unwrapped if `transcludeFn` |
| // is later passed as `parentBoundTranscludeFn` to `publicLinkFn` |
| transcludeFn = controllersBoundTransclude; |
| transcludeFn.$$boundTransclude = boundTranscludeFn; |
| } |
| |
| if (controllerDirectives) { |
| elementControllers = setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope); |
| } |
| |
| if (newIsolateScopeDirective) { |
| // Initialize isolate scope bindings for new isolate scope directive. |
| compile.$$addScopeInfo($element, isolateScope, true, !(templateDirective && (templateDirective === newIsolateScopeDirective || |
| templateDirective === newIsolateScopeDirective.$$originalDirective))); |
| compile.$$addScopeClass($element, true); |
| isolateScope.$$isolateBindings = |
| newIsolateScopeDirective.$$isolateBindings; |
| initializeDirectiveBindings(scope, attrs, isolateScope, |
| isolateScope.$$isolateBindings, |
| newIsolateScopeDirective, isolateScope); |
| } |
| if (elementControllers) { |
| // Initialize bindToController bindings for new/isolate scopes |
| var scopeDirective = newIsolateScopeDirective || newScopeDirective; |
| var bindings; |
| var controllerForBindings; |
| if (scopeDirective && elementControllers[scopeDirective.name]) { |
| bindings = scopeDirective.$$bindings.bindToController; |
| controller = elementControllers[scopeDirective.name]; |
| |
| if (controller && controller.identifier && bindings) { |
| controllerForBindings = controller; |
| thisLinkFn.$$destroyBindings = |
| initializeDirectiveBindings(scope, attrs, controller.instance, |
| bindings, scopeDirective); |
| } |
| } |
| for (i in elementControllers) { |
| controller = elementControllers[i]; |
| var controllerResult = controller(); |
| |
| if (controllerResult !== controller.instance) { |
| // If the controller constructor has a return value, overwrite the instance |
| // from setupControllers and update the element data |
| controller.instance = controllerResult; |
| $element.data('$' + i + 'Controller', controllerResult); |
| if (controller === controllerForBindings) { |
| // Remove and re-install bindToController bindings |
| thisLinkFn.$$destroyBindings(); |
| thisLinkFn.$$destroyBindings = |
| initializeDirectiveBindings(scope, attrs, controllerResult, bindings, scopeDirective); |
| } |
| } |
| } |
| } |
| |
| // PRELINKING |
| for (i = 0, ii = preLinkFns.length; i < ii; i++) { |
| linkFn = preLinkFns[i]; |
| invokeLinkFn(linkFn, |
| linkFn.isolateScope ? isolateScope : scope, |
| $element, |
| attrs, |
| linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers), |
| transcludeFn |
| ); |
| } |
| |
| // RECURSION |
| // We only pass the isolate scope, if the isolate directive has a template, |
| // otherwise the child elements do not belong to the isolate directive. |
| var scopeToChild = scope; |
| if (newIsolateScopeDirective && (newIsolateScopeDirective.template || newIsolateScopeDirective.templateUrl === null)) { |
| scopeToChild = isolateScope; |
| } |
| childLinkFn && childLinkFn(scopeToChild, linkNode.childNodes, undefined, boundTranscludeFn); |
| |
| // POSTLINKING |
| for (i = postLinkFns.length - 1; i >= 0; i--) { |
| linkFn = postLinkFns[i]; |
| invokeLinkFn(linkFn, |
| linkFn.isolateScope ? isolateScope : scope, |
| $element, |
| attrs, |
| linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers), |
| transcludeFn |
| ); |
| } |
| |
| // This is the function that is injected as `$transclude`. |
| // Note: all arguments are optional! |
| function controllersBoundTransclude(scope, cloneAttachFn, futureParentElement) { |
| var transcludeControllers; |
| |
| // No scope passed in: |
| if (!isScope(scope)) { |
| futureParentElement = cloneAttachFn; |
| cloneAttachFn = scope; |
| scope = undefined; |
| } |
| |
| if (hasElementTranscludeDirective) { |
| transcludeControllers = elementControllers; |
| } |
| if (!futureParentElement) { |
| futureParentElement = hasElementTranscludeDirective ? $element.parent() : $element; |
| } |
| return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild); |
| } |
| } |
| } |
| |
| function markDirectivesAsIsolate(directives) { |
| // mark all directives as needing isolate scope. |
| for (var j = 0, jj = directives.length; j < jj; j++) { |
| directives[j] = inherit(directives[j], {$$isolateScope: true}); |
| } |
| } |
| |
| /** |
| * looks up the directive and decorates it with exception handling and proper parameters. We |
| * call this the boundDirective. |
| * |
| * @param {string} name name of the directive to look up. |
| * @param {string} location The directive must be found in specific format. |
| * String containing any of theses characters: |
| * |
| * * `E`: element name |
| * * `A': attribute |
| * * `C`: class |
| * * `M`: comment |
| * @returns {boolean} true if directive was added. |
| */ |
| function addDirective(tDirectives, name, location, maxPriority, ignoreDirective, startAttrName, |
| endAttrName) { |
| if (name === ignoreDirective) return null; |
| var match = null; |
| if (hasDirectives.hasOwnProperty(name)) { |
| for (var directive, directives = $injector.get(name + Suffix), |
| i = 0, ii = directives.length; i < ii; i++) { |
| try { |
| directive = directives[i]; |
| if ((isUndefined(maxPriority) || maxPriority > directive.priority) && |
| directive.restrict.indexOf(location) != -1) { |
| if (startAttrName) { |
| directive = inherit(directive, {$$start: startAttrName, $$end: endAttrName}); |
| } |
| tDirectives.push(directive); |
| match = directive; |
| } |
| } catch (e) { $exceptionHandler(e); } |
| } |
| } |
| return match; |
| } |
| |
| |
| /** |
| * looks up the directive and returns true if it is a multi-element directive, |
| * and therefore requires DOM nodes between -start and -end markers to be grouped |
| * together. |
| * |
| * @param {string} name name of the directive to look up. |
| * @returns true if directive was registered as multi-element. |
| */ |
| function directiveIsMultiElement(name) { |
| if (hasDirectives.hasOwnProperty(name)) { |
| for (var directive, directives = $injector.get(name + Suffix), |
| i = 0, ii = directives.length; i < ii; i++) { |
| directive = directives[i]; |
| if (directive.multiElement) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * When the element is replaced with HTML template then the new attributes |
| * on the template need to be merged with the existing attributes in the DOM. |
| * The desired effect is to have both of the attributes present. |
| * |
| * @param {object} dst destination attributes (original DOM) |
| * @param {object} src source attributes (from the directive template) |
| */ |
| function mergeTemplateAttributes(dst, src) { |
| var srcAttr = src.$attr, |
| dstAttr = dst.$attr, |
| $element = dst.$$element; |
| |
| // reapply the old attributes to the new element |
| forEach(dst, function(value, key) { |
| if (key.charAt(0) != '$') { |
| if (src[key] && src[key] !== value) { |
| value += (key === 'style' ? ';' : ' ') + src[key]; |
| } |
| dst.$set(key, value, true, srcAttr[key]); |
| } |
| }); |
| |
| // copy the new attributes on the old attrs object |
| forEach(src, function(value, key) { |
| if (key == 'class') { |
| safeAddClass($element, value); |
| dst['class'] = (dst['class'] ? dst['class'] + ' ' : '') + value; |
| } else if (key == 'style') { |
| $element.attr('style', $element.attr('style') + ';' + value); |
| dst['style'] = (dst['style'] ? dst['style'] + ';' : '') + value; |
| // `dst` will never contain hasOwnProperty as DOM parser won't let it. |
| // You will get an "InvalidCharacterError: DOM Exception 5" error if you |
| // have an attribute like "has-own-property" or "data-has-own-property", etc. |
| } else if (key.charAt(0) != '$' && !dst.hasOwnProperty(key)) { |
| dst[key] = value; |
| dstAttr[key] = srcAttr[key]; |
| } |
| }); |
| } |
| |
| |
| function compileTemplateUrl(directives, $compileNode, tAttrs, |
| $rootElement, childTranscludeFn, preLinkFns, postLinkFns, previousCompileContext) { |
| var linkQueue = [], |
| afterTemplateNodeLinkFn, |
| afterTemplateChildLinkFn, |
| beforeTemplateCompileNode = $compileNode[0], |
| origAsyncDirective = directives.shift(), |
| derivedSyncDirective = inherit(origAsyncDirective, { |
| templateUrl: null, transclude: null, replace: null, $$originalDirective: origAsyncDirective |
| }), |
| templateUrl = (isFunction(origAsyncDirective.templateUrl)) |
| ? origAsyncDirective.templateUrl($compileNode, tAttrs) |
| : origAsyncDirective.templateUrl, |
| templateNamespace = origAsyncDirective.templateNamespace; |
| |
| $compileNode.empty(); |
| |
| $templateRequest(templateUrl) |
| .then(function(content) { |
| var compileNode, tempTemplateAttrs, $template, childBoundTranscludeFn; |
| |
| content = denormalizeTemplate(content); |
| |
| if (origAsyncDirective.replace) { |
| if (jqLiteIsTextNode(content)) { |
| $template = []; |
| } else { |
| $template = removeComments(wrapTemplate(templateNamespace, trim(content))); |
| } |
| compileNode = $template[0]; |
| |
| if ($template.length != 1 || compileNode.nodeType !== NODE_TYPE_ELEMENT) { |
| throw $compileMinErr('tplrt', |
| "Template for directive '{0}' must have exactly one root element. {1}", |
| origAsyncDirective.name, templateUrl); |
| } |
| |
| tempTemplateAttrs = {$attr: {}}; |
| replaceWith($rootElement, $compileNode, compileNode); |
| var templateDirectives = collectDirectives(compileNode, [], tempTemplateAttrs); |
| |
| if (isObject(origAsyncDirective.scope)) { |
| markDirectivesAsIsolate(templateDirectives); |
| } |
| directives = templateDirectives.concat(directives); |
| mergeTemplateAttributes(tAttrs, tempTemplateAttrs); |
| } else { |
| compileNode = beforeTemplateCompileNode; |
| $compileNode.html(content); |
| } |
| |
| directives.unshift(derivedSyncDirective); |
| |
| afterTemplateNodeLinkFn = applyDirectivesToNode(directives, compileNode, tAttrs, |
| childTranscludeFn, $compileNode, origAsyncDirective, preLinkFns, postLinkFns, |
| previousCompileContext); |
| forEach($rootElement, function(node, i) { |
| if (node == compileNode) { |
| $rootElement[i] = $compileNode[0]; |
| } |
| }); |
| afterTemplateChildLinkFn = compileNodes($compileNode[0].childNodes, childTranscludeFn); |
| |
| while (linkQueue.length) { |
| var scope = linkQueue.shift(), |
| beforeTemplateLinkNode = linkQueue.shift(), |
| linkRootElement = linkQueue.shift(), |
| boundTranscludeFn = linkQueue.shift(), |
| linkNode = $compileNode[0]; |
| |
| if (scope.$$destroyed) continue; |
| |
| if (beforeTemplateLinkNode !== beforeTemplateCompileNode) { |
| var oldClasses = beforeTemplateLinkNode.className; |
| |
| if (!(previousCompileContext.hasElementTranscludeDirective && |
| origAsyncDirective.replace)) { |
| // it was cloned therefore we have to clone as well. |
| linkNode = jqLiteClone(compileNode); |
| } |
| replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode); |
| |
| // Copy in CSS classes from original node |
| safeAddClass(jqLite(linkNode), oldClasses); |
| } |
| if (afterTemplateNodeLinkFn.transcludeOnThisElement) { |
| childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn); |
| } else { |
| childBoundTranscludeFn = boundTranscludeFn; |
| } |
| afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement, |
| childBoundTranscludeFn, afterTemplateNodeLinkFn); |
| } |
| linkQueue = null; |
| }); |
| |
| return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, boundTranscludeFn) { |
| var childBoundTranscludeFn = boundTranscludeFn; |
| if (scope.$$destroyed) return; |
| if (linkQueue) { |
| linkQueue.push(scope, |
| node, |
| rootElement, |
| childBoundTranscludeFn); |
| } else { |
| if (afterTemplateNodeLinkFn.transcludeOnThisElement) { |
| childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn); |
| } |
| afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, childBoundTranscludeFn, |
| afterTemplateNodeLinkFn); |
| } |
| }; |
| } |
| |
| |
| /** |
| * Sorting function for bound directives. |
| */ |
| function byPriority(a, b) { |
| var diff = b.priority - a.priority; |
| if (diff !== 0) return diff; |
| if (a.name !== b.name) return (a.name < b.name) ? -1 : 1; |
| return a.index - b.index; |
| } |
| |
| function assertNoDuplicate(what, previousDirective, directive, element) { |
| |
| function wrapModuleNameIfDefined(moduleName) { |
| return moduleName ? |
| (' (module: ' + moduleName + ')') : |
| ''; |
| } |
| |
| if (previousDirective) { |
| throw $compileMinErr('multidir', 'Multiple directives [{0}{1}, {2}{3}] asking for {4} on: {5}', |
| previousDirective.name, wrapModuleNameIfDefined(previousDirective.$$moduleName), |
| directive.name, wrapModuleNameIfDefined(directive.$$moduleName), what, startingTag(element)); |
| } |
| } |
| |
| |
| function addTextInterpolateDirective(directives, text) { |
| var interpolateFn = $interpolate(text, true); |
| if (interpolateFn) { |
| directives.push({ |
| priority: 0, |
| compile: function textInterpolateCompileFn(templateNode) { |
| var templateNodeParent = templateNode.parent(), |
| hasCompileParent = !!templateNodeParent.length; |
| |
| // When transcluding a template that has bindings in the root |
| // we don't have a parent and thus need to add the class during linking fn. |
| if (hasCompileParent) compile.$$addBindingClass(templateNodeParent); |
| |
| return function textInterpolateLinkFn(scope, node) { |
| var parent = node.parent(); |
| if (!hasCompileParent) compile.$$addBindingClass(parent); |
| compile.$$addBindingInfo(parent, interpolateFn.expressions); |
| scope.$watch(interpolateFn, function interpolateFnWatchAction(value) { |
| node[0].nodeValue = value; |
| }); |
| }; |
| } |
| }); |
| } |
| } |
| |
| |
| function wrapTemplate(type, template) { |
| type = lowercase(type || 'html'); |
| switch (type) { |
| case 'svg': |
| case 'math': |
| var wrapper = document.createElement('div'); |
| wrapper.innerHTML = '<' + type + '>' + template + '</' + type + '>'; |
| return wrapper.childNodes[0].childNodes; |
| default: |
| return template; |
| } |
| } |
| |
| |
| function getTrustedContext(node, attrNormalizedName) { |
| if (attrNormalizedName == "srcdoc") { |
| return $sce.HTML; |
| } |
| var tag = nodeName_(node); |
| // maction[xlink:href] can source SVG. It's not limited to <maction>. |
| if (attrNormalizedName == "xlinkHref" || |
| (tag == "form" && attrNormalizedName == "action") || |
| (tag != "img" && (attrNormalizedName == "src" || |
| attrNormalizedName == "ngSrc"))) { |
| return $sce.RESOURCE_URL; |
| } |
| } |
| |
| |
| function addAttrInterpolateDirective(node, directives, value, name, allOrNothing) { |
| var trustedContext = getTrustedContext(node, name); |
| allOrNothing = ALL_OR_NOTHING_ATTRS[name] || allOrNothing; |
| |
| var interpolateFn = $interpolate(value, true, trustedContext, allOrNothing); |
| |
| // no interpolation found -> ignore |
| if (!interpolateFn) return; |
| |
| |
| if (name === "multiple" && nodeName_(node) === "select") { |
| throw $compileMinErr("selmulti", |
| "Binding to the 'multiple' attribute is not supported. Element: {0}", |
| startingTag(node)); |
| } |
| |
| directives.push({ |
| priority: 100, |
| compile: function() { |
| return { |
| pre: function attrInterpolatePreLinkFn(scope, element, attr) { |
| var $$observers = (attr.$$observers || (attr.$$observers = createMap())); |
| |
| if (EVENT_HANDLER_ATTR_REGEXP.test(name)) { |
| throw $compileMinErr('nodomevents', |
| "Interpolations for HTML DOM event attributes are disallowed. Please use the " + |
| "ng- versions (such as ng-click instead of onclick) instead."); |
| } |
| |
| // If the attribute has changed since last $interpolate()ed |
| var newValue = attr[name]; |
| if (newValue !== value) { |
| // we need to interpolate again since the attribute value has been updated |
| // (e.g. by another directive's compile function) |
| // ensure unset/empty values make interpolateFn falsy |
| interpolateFn = newValue && $interpolate(newValue, true, trustedContext, allOrNothing); |
| value = newValue; |
| } |
| |
| // if attribute was updated so that there is no interpolation going on we don't want to |
| // register any observers |
| if (!interpolateFn) return; |
| |
| // initialize attr object so that it's ready in case we need the value for isolate |
| // scope initialization, otherwise the value would not be available from isolate |
| // directive's linking fn during linking phase |
| attr[name] = interpolateFn(scope); |
| |
| ($$observers[name] || ($$observers[name] = [])).$$inter = true; |
| (attr.$$observers && attr.$$observers[name].$$scope || scope). |
| $watch(interpolateFn, function interpolateFnWatchAction(newValue, oldValue) { |
| //special case for class attribute addition + removal |
| //so that class changes can tap into the animation |
| //hooks provided by the $animate service. Be sure to |
| //skip animations when the first digest occurs (when |
| //both the new and the old values are the same) since |
| //the CSS classes are the non-interpolated values |
| if (name === 'class' && newValue != oldValue) { |
| attr.$updateClass(newValue, oldValue); |
| } else { |
| attr.$set(name, newValue); |
| } |
| }); |
| } |
| }; |
| } |
| }); |
| } |
| |
| |
| /** |
| * This is a special jqLite.replaceWith, which can replace items which |
| * have no parents, provided that the containing jqLite collection is provided. |
| * |
| * @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes |
| * in the root of the tree. |
| * @param {JqLite} elementsToRemove The jqLite element which we are going to replace. We keep |
| * the shell, but replace its DOM node reference. |
| * @param {Node} newNode The new DOM node. |
| */ |
| function replaceWith($rootElement, elementsToRemove, newNode) { |
| var firstElementToRemove = elementsToRemove[0], |
| removeCount = elementsToRemove.length, |
| parent = firstElementToRemove.parentNode, |
| i, ii; |
| |
| if ($rootElement) { |
| for (i = 0, ii = $rootElement.length; i < ii; i++) { |
| if ($rootElement[i] == firstElementToRemove) { |
| $rootElement[i++] = newNode; |
| for (var j = i, j2 = j + removeCount - 1, |
| jj = $rootElement.length; |
| j < jj; j++, j2++) { |
| if (j2 < jj) { |
| $rootElement[j] = $rootElement[j2]; |
| } else { |
| delete $rootElement[j]; |
| } |
| } |
| $rootElement.length -= removeCount - 1; |
| |
| // If the replaced element is also the jQuery .context then replace it |
| // .context is a deprecated jQuery api, so we should set it only when jQuery set it |
| // http://api.jquery.com/context/ |
| if ($rootElement.context === firstElementToRemove) { |
| $rootElement.context = newNode; |
| } |
| break; |
| } |
| } |
| } |
| |
| if (parent) { |
| parent.replaceChild(newNode, firstElementToRemove); |
| } |
| |
| // TODO(perf): what's this document fragment for? is it needed? can we at least reuse it? |
| var fragment = document.createDocumentFragment(); |
| fragment.appendChild(firstElementToRemove); |
| |
| if (jqLite.hasData(firstElementToRemove)) { |
| // Copy over user data (that includes Angular's $scope etc.). Don't copy private |
| // data here because there's no public interface in jQuery to do that and copying over |
| // event listeners (which is the main use of private data) wouldn't work anyway. |
| jqLite(newNode).data(jqLite(firstElementToRemove).data()); |
| |
| // Remove data of the replaced element. We cannot just call .remove() |
| // on the element it since that would deallocate scope that is needed |
| // for the new node. Instead, remove the data "manually". |
| if (!jQuery) { |
| delete jqLite.cache[firstElementToRemove[jqLite.expando]]; |
| } else { |
| // jQuery 2.x doesn't expose the data storage. Use jQuery.cleanData to clean up after |
| // the replaced element. The cleanData version monkey-patched by Angular would cause |
| // the scope to be trashed and we do need the very same scope to work with the new |
| // element. However, we cannot just cache the non-patched version and use it here as |
| // that would break if another library patches the method after Angular does (one |
| // example is jQuery UI). Instead, set a flag indicating scope destroying should be |
| // skipped this one time. |
| skipDestroyOnNextJQueryCleanData = true; |
| jQuery.cleanData([firstElementToRemove]); |
| } |
| } |
| |
| for (var k = 1, kk = elementsToRemove.length; k < kk; k++) { |
| var element = elementsToRemove[k]; |
| jqLite(element).remove(); // must do this way to clean up expando |
| fragment.appendChild(element); |
| delete elementsToRemove[k]; |
| } |
| |
| elementsToRemove[0] = newNode; |
| elementsToRemove.length = 1; |
| } |
| |
| |
| function cloneAndAnnotateFn(fn, annotation) { |
| return extend(function() { return fn.apply(null, arguments); }, fn, annotation); |
| } |
| |
| |
| function invokeLinkFn(linkFn, scope, $element, attrs, controllers, transcludeFn) { |
| try { |
| linkFn(scope, $element, attrs, controllers, transcludeFn); |
| } catch (e) { |
| $exceptionHandler(e, startingTag($element)); |
| } |
| } |
| |
| |
| // Set up $watches for isolate scope and controller bindings. This process |
| // only occurs for isolate scopes and new scopes with controllerAs. |
| function initializeDirectiveBindings(scope, attrs, destination, bindings, |
| directive, newScope) { |
| var onNewScopeDestroyed; |
| forEach(bindings, function(definition, scopeName) { |
| var attrName = definition.attrName, |
| optional = definition.optional, |
| mode = definition.mode, // @, =, or & |
| lastValue, |
| parentGet, parentSet, compare; |
| |
| switch (mode) { |
| |
| case '@': |
| if (!optional && !hasOwnProperty.call(attrs, attrName)) { |
| destination[scopeName] = attrs[attrName] = void 0; |
| } |
| attrs.$observe(attrName, function(value) { |
| if (isString(value)) { |
| destination[scopeName] = value; |
| } |
| }); |
| attrs.$$observers[attrName].$$scope = scope; |
| if (isString(attrs[attrName])) { |
| // If the attribute has been provided then we trigger an interpolation to ensure |
| // the value is there for use in the link fn |
| destination[scopeName] = $interpolate(attrs[attrName])(scope); |
| } |
| break; |
| |
| case '=': |
| if (!hasOwnProperty.call(attrs, attrName)) { |
| if (optional) break; |
| attrs[attrName] = void 0; |
| } |
| if (optional && !attrs[attrName]) break; |
| |
| parentGet = $parse(attrs[attrName]); |
| if (parentGet.literal) { |
| compare = equals; |
| } else { |
| compare = function(a, b) { return a === b || (a !== a && b !== b); }; |
| } |
| parentSet = parentGet.assign || function() { |
| // reset the change, or we will throw this exception on every $digest |
| lastValue = destination[scopeName] = parentGet(scope); |
| throw $compileMinErr('nonassign', |
| "Expression '{0}' used with directive '{1}' is non-assignable!", |
| attrs[attrName], directive.name); |
| }; |
| lastValue = destination[scopeName] = parentGet(scope); |
| var parentValueWatch = function parentValueWatch(parentValue) { |
| if (!compare(parentValue, destination[scopeName])) { |
| // we are out of sync and need to copy |
| if (!compare(parentValue, lastValue)) { |
| // parent changed and it has precedence |
| destination[scopeName] = parentValue; |
| } else { |
| // if the parent can be assigned then do so |
| parentSet(scope, parentValue = destination[scopeName]); |
| } |
| } |
| return lastValue = parentValue; |
| }; |
| parentValueWatch.$stateful = true; |
| var unwatch; |
| if (definition.collection) { |
| unwatch = scope.$watchCollection(attrs[attrName], parentValueWatch); |
| } else { |
| unwatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal); |
| } |
| onNewScopeDestroyed = (onNewScopeDestroyed || []); |
| onNewScopeDestroyed.push(unwatch); |
| break; |
| |
| case '&': |
| // Don't assign Object.prototype method to scope |
| parentGet = attrs.hasOwnProperty(attrName) ? $parse(attrs[attrName]) : noop; |
| |
| // Don't assign noop to destination if expression is not valid |
| if (parentGet === noop && optional) break; |
| |
| destination[scopeName] = function(locals) { |
| return parentGet(scope, locals); |
| }; |
| break; |
| } |
| }); |
| var destroyBindings = onNewScopeDestroyed ? function destroyBindings() { |
| for (var i = 0, ii = onNewScopeDestroyed.length; i < ii; ++i) { |
| onNewScopeDestroyed[i](); |
| } |
| } : noop; |
| if (newScope && destroyBindings !== noop) { |
| newScope.$on('$destroy', destroyBindings); |
| return noop; |
| } |
| return destroyBindings; |
| } |
| }]; |
| } |
| |
| var PREFIX_REGEXP = /^((?:x|data)[\:\-_])/i; |
| /** |
| * Converts all accepted directives format into proper directive name. |
| * @param name Name to normalize |
| */ |
| function directiveNormalize(name) { |
| return camelCase(name.replace(PREFIX_REGEXP, '')); |
| } |
| |
| /** |
| * @ngdoc type |
| * @name $compile.directive.Attributes |
| * |
| * @description |
| * A shared object between directive compile / linking functions which contains normalized DOM |
| * element attributes. The values reflect current binding state `{{ }}`. The normalization is |
| * needed since all of these are treated as equivalent in Angular: |
| * |
| * ``` |
| * <span ng:bind="a" ng-bind="a" data-ng-bind="a" x-ng-bind="a"> |
| * ``` |
| */ |
| |
| /** |
| * @ngdoc property |
| * @name $compile.directive.Attributes#$attr |
| * |
| * @description |
| * A map of DOM element attribute names to the normalized name. This is |
| * needed to do reverse lookup from normalized name back to actual name. |
| */ |
| |
| |
| /** |
| * @ngdoc method |
| * @name $compile.directive.Attributes#$set |
| * @kind function |
| * |
| * @description |
| * Set DOM element attribute value. |
| * |
| * |
| * @param {string} name Normalized element attribute name of the property to modify. The name is |
| * reverse-translated using the {@link ng.$compile.directive.Attributes#$attr $attr} |
| * property to the original name. |
| * @param {string} value Value to set the attribute to. The value can be an interpolated string. |
| */ |
| |
| |
| |
| /** |
| * Closure compiler type information |
| */ |
| |
| function nodesetLinkingFn( |
| /* angular.Scope */ scope, |
| /* NodeList */ nodeList, |
| /* Element */ rootElement, |
| /* function(Function) */ boundTranscludeFn |
| ) {} |
| |
| function directiveLinkingFn( |
| /* nodesetLinkingFn */ nodesetLinkingFn, |
| /* angular.Scope */ scope, |
| /* Node */ node, |
| /* Element */ rootElement, |
| /* function(Function) */ boundTranscludeFn |
| ) {} |
| |
| function tokenDifference(str1, str2) { |
| var values = '', |
| tokens1 = str1.split(/\s+/), |
| tokens2 = str2.split(/\s+/); |
| |
| outer: |
| for (var i = 0; i < tokens1.length; i++) { |
| var token = tokens1[i]; |
| for (var j = 0; j < tokens2.length; j++) { |
| if (token == tokens2[j]) continue outer; |
| } |
| values += (values.length > 0 ? ' ' : '') + token; |
| } |
| return values; |
| } |
| |
| function removeComments(jqNodes) { |
| jqNodes = jqLite(jqNodes); |
| var i = jqNodes.length; |
| |
| if (i <= 1) { |
| return jqNodes; |
| } |
| |
| while (i--) { |
| var node = jqNodes[i]; |
| if (node.nodeType === NODE_TYPE_COMMENT) { |
| splice.call(jqNodes, i, 1); |
| } |
| } |
| return jqNodes; |
| } |
| |
| var $controllerMinErr = minErr('$controller'); |
| |
| |
| var CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/; |
| function identifierForController(controller, ident) { |
| if (ident && isString(ident)) return ident; |
| if (isString(controller)) { |
| var match = CNTRL_REG.exec(controller); |
| if (match) return match[3]; |
| } |
| } |
| |
| |
| /** |
| * @ngdoc provider |
| * @name $controllerProvider |
| * @description |
| * The {@link ng.$controller $controller service} is used by Angular to create new |
| * controllers. |
| * |
| * This provider allows controller registration via the |
| * {@link ng.$controllerProvider#register register} method. |
| */ |
| function $ControllerProvider() { |
| var controllers = {}, |
| globals = false; |
| |
| /** |
| * @ngdoc method |
| * @name $controllerProvider#register |
| * @param {string|Object} name Controller name, or an object map of controllers where the keys are |
| * the names and the values are the constructors. |
| * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI |
| * annotations in the array notation). |
| */ |
| this.register = function(name, constructor) { |
| assertNotHasOwnProperty(name, 'controller'); |
| if (isObject(name)) { |
| extend(controllers, name); |
| } else { |
| controllers[name] = constructor; |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $controllerProvider#allowGlobals |
| * @description If called, allows `$controller` to find controller constructors on `window` |
| */ |
| this.allowGlobals = function() { |
| globals = true; |
| }; |
| |
| |
| this.$get = ['$injector', '$window', function($injector, $window) { |
| |
| /** |
| * @ngdoc service |
| * @name $controller |
| * @requires $injector |
| * |
| * @param {Function|string} constructor If called with a function then it's considered to be the |
| * controller constructor function. Otherwise it's considered to be a string which is used |
| * to retrieve the controller constructor using the following steps: |
| * |
| * * check if a controller with given name is registered via `$controllerProvider` |
| * * check if evaluating the string on the current scope returns a constructor |
| * * if $controllerProvider#allowGlobals, check `window[constructor]` on the global |
| * `window` object (not recommended) |
| * |
| * The string can use the `controller as property` syntax, where the controller instance is published |
| * as the specified property on the `scope`; the `scope` must be injected into `locals` param for this |
| * to work correctly. |
| * |
| * @param {Object} locals Injection locals for Controller. |
| * @return {Object} Instance of given controller. |
| * |
| * @description |
| * `$controller` service is responsible for instantiating controllers. |
| * |
| * It's just a simple call to {@link auto.$injector $injector}, but extracted into |
| * a service, so that one can override this service with [BC version](https://gist.github.com/1649788). |
| */ |
| return function(expression, locals, later, ident) { |
| // PRIVATE API: |
| // param `later` --- indicates that the controller's constructor is invoked at a later time. |
| // If true, $controller will allocate the object with the correct |
| // prototype chain, but will not invoke the controller until a returned |
| // callback is invoked. |
| // param `ident` --- An optional label which overrides the label parsed from the controller |
| // expression, if any. |
| var instance, match, constructor, identifier; |
| later = later === true; |
| if (ident && isString(ident)) { |
| identifier = ident; |
| } |
| |
| if (isString(expression)) { |
| match = expression.match(CNTRL_REG); |
| if (!match) { |
| throw $controllerMinErr('ctrlfmt', |
| "Badly formed controller string '{0}'. " + |
| "Must match `__name__ as __id__` or `__name__`.", expression); |
| } |
| constructor = match[1], |
| identifier = identifier || match[3]; |
| expression = controllers.hasOwnProperty(constructor) |
| ? controllers[constructor] |
| : getter(locals.$scope, constructor, true) || |
| (globals ? getter($window, constructor, true) : undefined); |
| |
| assertArgFn(expression, constructor, true); |
| } |
| |
| if (later) { |
| // Instantiate controller later: |
| // This machinery is used to create an instance of the object before calling the |
| // controller's constructor itself. |
| // |
| // This allows properties to be added to the controller before the constructor is |
| // invoked. Primarily, this is used for isolate scope bindings in $compile. |
| // |
| // This feature is not intended for use by applications, and is thus not documented |
| // publicly. |
| // Object creation: http://jsperf.com/create-constructor/2 |
| var controllerPrototype = (isArray(expression) ? |
| expression[expression.length - 1] : expression).prototype; |
| instance = Object.create(controllerPrototype || null); |
| |
| if (identifier) { |
| addIdentifier(locals, identifier, instance, constructor || expression.name); |
| } |
| |
| var instantiate; |
| return instantiate = extend(function() { |
| var result = $injector.invoke(expression, instance, locals, constructor); |
| if (result !== instance && (isObject(result) || isFunction(result))) { |
| instance = result; |
| if (identifier) { |
| // If result changed, re-assign controllerAs value to scope. |
| addIdentifier(locals, identifier, instance, constructor || expression.name); |
| } |
| } |
| return instance; |
| }, { |
| instance: instance, |
| identifier: identifier |
| }); |
| } |
| |
| instance = $injector.instantiate(expression, locals, constructor); |
| |
| if (identifier) { |
| addIdentifier(locals, identifier, instance, constructor || expression.name); |
| } |
| |
| return instance; |
| }; |
| |
| function addIdentifier(locals, identifier, instance, name) { |
| if (!(locals && isObject(locals.$scope))) { |
| throw minErr('$controller')('noscp', |
| "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.", |
| name, identifier); |
| } |
| |
| locals.$scope[identifier] = instance; |
| } |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $document |
| * @requires $window |
| * |
| * @description |
| * A {@link angular.element jQuery or jqLite} wrapper for the browser's `window.document` object. |
| * |
| * @example |
| <example module="documentExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <p>$document title: <b ng-bind="title"></b></p> |
| <p>window.document title: <b ng-bind="windowTitle"></b></p> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('documentExample', []) |
| .controller('ExampleController', ['$scope', '$document', function($scope, $document) { |
| $scope.title = $document[0].title; |
| $scope.windowTitle = angular.element(window.document)[0].title; |
| }]); |
| </file> |
| </example> |
| */ |
| function $DocumentProvider() { |
| this.$get = ['$window', function(window) { |
| return jqLite(window.document); |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $exceptionHandler |
| * @requires ng.$log |
| * |
| * @description |
| * Any uncaught exception in angular expressions is delegated to this service. |
| * The default implementation simply delegates to `$log.error` which logs it into |
| * the browser console. |
| * |
| * In unit tests, if `angular-mocks.js` is loaded, this service is overridden by |
| * {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing. |
| * |
| * ## Example: |
| * |
| * ```js |
| * angular.module('exceptionOverride', []).factory('$exceptionHandler', function() { |
| * return function(exception, cause) { |
| * exception.message += ' (caused by "' + cause + '")'; |
| * throw exception; |
| * }; |
| * }); |
| * ``` |
| * |
| * This example will override the normal action of `$exceptionHandler`, to make angular |
| * exceptions fail hard when they happen, instead of just logging to the console. |
| * |
| * <hr /> |
| * Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind` |
| * methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler} |
| * (unless executed during a digest). |
| * |
| * If you wish, you can manually delegate exceptions, e.g. |
| * `try { ... } catch(e) { $exceptionHandler(e); }` |
| * |
| * @param {Error} exception Exception associated with the error. |
| * @param {string=} cause optional information about the context in which |
| * the error was thrown. |
| * |
| */ |
| function $ExceptionHandlerProvider() { |
| this.$get = ['$log', function($log) { |
| return function(exception, cause) { |
| $log.error.apply($log, arguments); |
| }; |
| }]; |
| } |
| |
| var $$ForceReflowProvider = function() { |
| this.$get = ['$document', function($document) { |
| return function(domNode) { |
| //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 |
| //ensure that the preparation animation is properly flushed so that |
| //the active state picks up from there. DO NOT REMOVE THIS LINE. |
| //DO NOT OPTIMIZE THIS LINE. THE MINIFIER WILL REMOVE IT OTHERWISE WHICH |
| //WILL RESULT IN AN UNPREDICTABLE BUG THAT IS VERY HARD TO TRACK DOWN AND |
| //WILL TAKE YEARS AWAY FROM YOUR LIFE. |
| if (domNode) { |
| if (!domNode.nodeType && domNode instanceof jqLite) { |
| domNode = domNode[0]; |
| } |
| } else { |
| domNode = $document[0].body; |
| } |
| return domNode.offsetWidth + 1; |
| }; |
| }]; |
| }; |
| |
| var APPLICATION_JSON = 'application/json'; |
| var CONTENT_TYPE_APPLICATION_JSON = {'Content-Type': APPLICATION_JSON + ';charset=utf-8'}; |
| var JSON_START = /^\[|^\{(?!\{)/; |
| var JSON_ENDS = { |
| '[': /]$/, |
| '{': /}$/ |
| }; |
| var JSON_PROTECTION_PREFIX = /^\)\]\}',?\n/; |
| var $httpMinErr = minErr('$http'); |
| var $httpMinErrLegacyFn = function(method) { |
| return function() { |
| throw $httpMinErr('legacy', 'The method `{0}` on the promise returned from `$http` has been disabled.', method); |
| }; |
| }; |
| |
| function serializeValue(v) { |
| if (isObject(v)) { |
| return isDate(v) ? v.toISOString() : toJson(v); |
| } |
| return v; |
| } |
| |
| |
| function $HttpParamSerializerProvider() { |
| /** |
| * @ngdoc service |
| * @name $httpParamSerializer |
| * @description |
| * |
| * Default {@link $http `$http`} params serializer that converts objects to strings |
| * according to the following rules: |
| * |
| * * `{'foo': 'bar'}` results in `foo=bar` |
| * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object) |
| * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element) |
| * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D"` (stringified and encoded representation of an object) |
| * |
| * Note that serializer will sort the request parameters alphabetically. |
| * */ |
| |
| this.$get = function() { |
| return function ngParamSerializer(params) { |
| if (!params) return ''; |
| var parts = []; |
| forEachSorted(params, function(value, key) { |
| if (value === null || isUndefined(value)) return; |
| if (isArray(value)) { |
| forEach(value, function(v, k) { |
| parts.push(encodeUriQuery(key) + '=' + encodeUriQuery(serializeValue(v))); |
| }); |
| } else { |
| parts.push(encodeUriQuery(key) + '=' + encodeUriQuery(serializeValue(value))); |
| } |
| }); |
| |
| return parts.join('&'); |
| }; |
| }; |
| } |
| |
| function $HttpParamSerializerJQLikeProvider() { |
| /** |
| * @ngdoc service |
| * @name $httpParamSerializerJQLike |
| * @description |
| * |
| * Alternative {@link $http `$http`} params serializer that follows |
| * jQuery's [`param()`](http://api.jquery.com/jquery.param/) method logic. |
| * The serializer will also sort the params alphabetically. |
| * |
| * To use it for serializing `$http` request parameters, set it as the `paramSerializer` property: |
| * |
| * ```js |
| * $http({ |
| * url: myUrl, |
| * method: 'GET', |
| * params: myParams, |
| * paramSerializer: '$httpParamSerializerJQLike' |
| * }); |
| * ``` |
| * |
| * It is also possible to set it as the default `paramSerializer` in the |
| * {@link $httpProvider#defaults `$httpProvider`}. |
| * |
| * Additionally, you can inject the serializer and use it explicitly, for example to serialize |
| * form data for submission: |
| * |
| * ```js |
| * .controller(function($http, $httpParamSerializerJQLike) { |
| * //... |
| * |
| * $http({ |
| * url: myUrl, |
| * method: 'POST', |
| * data: $httpParamSerializerJQLike(myData), |
| * headers: { |
| * 'Content-Type': 'application/x-www-form-urlencoded' |
| * } |
| * }); |
| * |
| * }); |
| * ``` |
| * |
| * */ |
| this.$get = function() { |
| return function jQueryLikeParamSerializer(params) { |
| if (!params) return ''; |
| var parts = []; |
| serialize(params, '', true); |
| return parts.join('&'); |
| |
| function serialize(toSerialize, prefix, topLevel) { |
| if (toSerialize === null || isUndefined(toSerialize)) return; |
| if (isArray(toSerialize)) { |
| forEach(toSerialize, function(value, index) { |
| serialize(value, prefix + '[' + (isObject(value) ? index : '') + ']'); |
| }); |
| } else if (isObject(toSerialize) && !isDate(toSerialize)) { |
| forEachSorted(toSerialize, function(value, key) { |
| serialize(value, prefix + |
| (topLevel ? '' : '[') + |
| key + |
| (topLevel ? '' : ']')); |
| }); |
| } else { |
| parts.push(encodeUriQuery(prefix) + '=' + encodeUriQuery(serializeValue(toSerialize))); |
| } |
| } |
| }; |
| }; |
| } |
| |
| function defaultHttpResponseTransform(data, headers) { |
| if (isString(data)) { |
| // Strip json vulnerability protection prefix and trim whitespace |
| var tempData = data.replace(JSON_PROTECTION_PREFIX, '').trim(); |
| |
| if (tempData) { |
| var contentType = headers('Content-Type'); |
| if ((contentType && (contentType.indexOf(APPLICATION_JSON) === 0)) || isJsonLike(tempData)) { |
| data = fromJson(tempData); |
| } |
| } |
| } |
| |
| return data; |
| } |
| |
| function isJsonLike(str) { |
| var jsonStart = str.match(JSON_START); |
| return jsonStart && JSON_ENDS[jsonStart[0]].test(str); |
| } |
| |
| /** |
| * Parse headers into key value object |
| * |
| * @param {string} headers Raw headers as a string |
| * @returns {Object} Parsed headers as key value object |
| */ |
| function parseHeaders(headers) { |
| var parsed = createMap(), i; |
| |
| function fillInParsed(key, val) { |
| if (key) { |
| parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; |
| } |
| } |
| |
| if (isString(headers)) { |
| forEach(headers.split('\n'), function(line) { |
| i = line.indexOf(':'); |
| fillInParsed(lowercase(trim(line.substr(0, i))), trim(line.substr(i + 1))); |
| }); |
| } else if (isObject(headers)) { |
| forEach(headers, function(headerVal, headerKey) { |
| fillInParsed(lowercase(headerKey), trim(headerVal)); |
| }); |
| } |
| |
| return parsed; |
| } |
| |
| |
| /** |
| * Returns a function that provides access to parsed headers. |
| * |
| * Headers are lazy parsed when first requested. |
| * @see parseHeaders |
| * |
| * @param {(string|Object)} headers Headers to provide access to. |
| * @returns {function(string=)} Returns a getter function which if called with: |
| * |
| * - if called with single an argument returns a single header value or null |
| * - if called with no arguments returns an object containing all headers. |
| */ |
| function headersGetter(headers) { |
| var headersObj; |
| |
| return function(name) { |
| if (!headersObj) headersObj = parseHeaders(headers); |
| |
| if (name) { |
| var value = headersObj[lowercase(name)]; |
| if (value === void 0) { |
| value = null; |
| } |
| return value; |
| } |
| |
| return headersObj; |
| }; |
| } |
| |
| |
| /** |
| * Chain all given functions |
| * |
| * This function is used for both request and response transforming |
| * |
| * @param {*} data Data to transform. |
| * @param {function(string=)} headers HTTP headers getter fn. |
| * @param {number} status HTTP status code of the response. |
| * @param {(Function|Array.<Function>)} fns Function or an array of functions. |
| * @returns {*} Transformed data. |
| */ |
| function transformData(data, headers, status, fns) { |
| if (isFunction(fns)) { |
| return fns(data, headers, status); |
| } |
| |
| forEach(fns, function(fn) { |
| data = fn(data, headers, status); |
| }); |
| |
| return data; |
| } |
| |
| |
| function isSuccess(status) { |
| return 200 <= status && status < 300; |
| } |
| |
| |
| /** |
| * @ngdoc provider |
| * @name $httpProvider |
| * @description |
| * Use `$httpProvider` to change the default behavior of the {@link ng.$http $http} service. |
| * */ |
| function $HttpProvider() { |
| /** |
| * @ngdoc property |
| * @name $httpProvider#defaults |
| * @description |
| * |
| * Object containing default values for all {@link ng.$http $http} requests. |
| * |
| * - **`defaults.cache`** - {Object} - an object built with {@link ng.$cacheFactory `$cacheFactory`} |
| * that will provide the cache for all requests who set their `cache` property to `true`. |
| * If you set the `defaults.cache = false` then only requests that specify their own custom |
| * cache object will be cached. See {@link $http#caching $http Caching} for more information. |
| * |
| * - **`defaults.xsrfCookieName`** - {string} - Name of cookie containing the XSRF token. |
| * Defaults value is `'XSRF-TOKEN'`. |
| * |
| * - **`defaults.xsrfHeaderName`** - {string} - Name of HTTP header to populate with the |
| * XSRF token. Defaults value is `'X-XSRF-TOKEN'`. |
| * |
| * - **`defaults.headers`** - {Object} - Default headers for all $http requests. |
| * Refer to {@link ng.$http#setting-http-headers $http} for documentation on |
| * setting default headers. |
| * - **`defaults.headers.common`** |
| * - **`defaults.headers.post`** |
| * - **`defaults.headers.put`** |
| * - **`defaults.headers.patch`** |
| * |
| * |
| * - **`defaults.paramSerializer`** - `{string|function(Object<string,string>):string}` - A function |
| * used to the prepare string representation of request parameters (specified as an object). |
| * If specified as string, it is interpreted as a function registered with the {@link auto.$injector $injector}. |
| * Defaults to {@link ng.$httpParamSerializer $httpParamSerializer}. |
| * |
| **/ |
| var defaults = this.defaults = { |
| // transform incoming response data |
| transformResponse: [defaultHttpResponseTransform], |
| |
| // transform outgoing request data |
| transformRequest: [function(d) { |
| return isObject(d) && !isFile(d) && !isBlob(d) && !isFormData(d) ? toJson(d) : d; |
| }], |
| |
| // default headers |
| headers: { |
| common: { |
| 'Accept': 'application/json, text/plain, */*' |
| }, |
| post: shallowCopy(CONTENT_TYPE_APPLICATION_JSON), |
| put: shallowCopy(CONTENT_TYPE_APPLICATION_JSON), |
| patch: shallowCopy(CONTENT_TYPE_APPLICATION_JSON) |
| }, |
| |
| xsrfCookieName: 'XSRF-TOKEN', |
| xsrfHeaderName: 'X-XSRF-TOKEN', |
| |
| paramSerializer: '$httpParamSerializer' |
| }; |
| |
| var useApplyAsync = false; |
| /** |
| * @ngdoc method |
| * @name $httpProvider#useApplyAsync |
| * @description |
| * |
| * Configure $http service to combine processing of multiple http responses received at around |
| * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in |
| * significant performance improvement for bigger applications that make many HTTP requests |
| * concurrently (common during application bootstrap). |
| * |
| * Defaults to false. If no value is specified, returns the current configured value. |
| * |
| * @param {boolean=} value If true, when requests are loaded, they will schedule a deferred |
| * "apply" on the next tick, giving time for subsequent requests in a roughly ~10ms window |
| * to load and share the same digest cycle. |
| * |
| * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining. |
| * otherwise, returns the current configured value. |
| **/ |
| this.useApplyAsync = function(value) { |
| if (isDefined(value)) { |
| useApplyAsync = !!value; |
| return this; |
| } |
| return useApplyAsync; |
| }; |
| |
| var useLegacyPromise = true; |
| /** |
| * @ngdoc method |
| * @name $httpProvider#useLegacyPromiseExtensions |
| * @description |
| * |
| * Configure `$http` service to return promises without the shorthand methods `success` and `error`. |
| * This should be used to make sure that applications work without these methods. |
| * |
| * Defaults to false. If no value is specified, returns the current configured value. |
| * |
| * @param {boolean=} value If true, `$http` will return a normal promise without the `success` and `error` methods. |
| * |
| * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining. |
| * otherwise, returns the current configured value. |
| **/ |
| this.useLegacyPromiseExtensions = function(value) { |
| if (isDefined(value)) { |
| useLegacyPromise = !!value; |
| return this; |
| } |
| return useLegacyPromise; |
| }; |
| |
| /** |
| * @ngdoc property |
| * @name $httpProvider#interceptors |
| * @description |
| * |
| * Array containing service factories for all synchronous or asynchronous {@link ng.$http $http} |
| * pre-processing of request or postprocessing of responses. |
| * |
| * These service factories are ordered by request, i.e. they are applied in the same order as the |
| * array, on request, but reverse order, on response. |
| * |
| * {@link ng.$http#interceptors Interceptors detailed info} |
| **/ |
| var interceptorFactories = this.interceptors = []; |
| |
| this.$get = ['$httpBackend', '$$cookieReader', '$cacheFactory', '$rootScope', '$q', '$injector', |
| function($httpBackend, $$cookieReader, $cacheFactory, $rootScope, $q, $injector) { |
| |
| var defaultCache = $cacheFactory('$http'); |
| |
| /** |
| * Make sure that default param serializer is exposed as a function |
| */ |
| defaults.paramSerializer = isString(defaults.paramSerializer) ? |
| $injector.get(defaults.paramSerializer) : defaults.paramSerializer; |
| |
| /** |
| * Interceptors stored in reverse order. Inner interceptors before outer interceptors. |
| * The reversal is needed so that we can build up the interception chain around the |
| * server request. |
| */ |
| var reversedInterceptors = []; |
| |
| forEach(interceptorFactories, function(interceptorFactory) { |
| reversedInterceptors.unshift(isString(interceptorFactory) |
| ? $injector.get(interceptorFactory) : $injector.invoke(interceptorFactory)); |
| }); |
| |
| /** |
| * @ngdoc service |
| * @kind function |
| * @name $http |
| * @requires ng.$httpBackend |
| * @requires $cacheFactory |
| * @requires $rootScope |
| * @requires $q |
| * @requires $injector |
| * |
| * @description |
| * The `$http` service is a core Angular service that facilitates communication with the remote |
| * HTTP servers via the browser's [XMLHttpRequest](https://developer.mozilla.org/en/xmlhttprequest) |
| * object or via [JSONP](http://en.wikipedia.org/wiki/JSONP). |
| * |
| * For unit testing applications that use `$http` service, see |
| * {@link ngMock.$httpBackend $httpBackend mock}. |
| * |
| * For a higher level of abstraction, please check out the {@link ngResource.$resource |
| * $resource} service. |
| * |
| * The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by |
| * the $q service. While for simple usage patterns this doesn't matter much, for advanced usage |
| * it is important to familiarize yourself with these APIs and the guarantees they provide. |
| * |
| * |
| * ## General usage |
| * The `$http` service is a function which takes a single argument — a {@link $http#usage configuration object} — |
| * that is used to generate an HTTP request and returns a {@link ng.$q promise}. |
| * |
| * ```js |
| * // Simple GET request example: |
| * $http({ |
| * method: 'GET', |
| * url: '/someUrl' |
| * }).then(function successCallback(response) { |
| * // this callback will be called asynchronously |
| * // when the response is available |
| * }, function errorCallback(response) { |
| * // called asynchronously if an error occurs |
| * // or server returns response with an error status. |
| * }); |
| * ``` |
| * |
| * The response object has these properties: |
| * |
| * - **data** – `{string|Object}` – The response body transformed with the transform |
| * functions. |
| * - **status** – `{number}` – HTTP status code of the response. |
| * - **headers** – `{function([headerName])}` – Header getter function. |
| * - **config** – `{Object}` – The configuration object that was used to generate the request. |
| * - **statusText** – `{string}` – HTTP status text of the response. |
| * |
| * A response status code between 200 and 299 is considered a success status and |
| * will result in the success callback being called. Note that if the response is a redirect, |
| * XMLHttpRequest will transparently follow it, meaning that the error callback will not be |
| * called for such responses. |
| * |
| * |
| * ## Shortcut methods |
| * |
| * Shortcut methods are also available. All shortcut methods require passing in the URL, and |
| * request data must be passed in for POST/PUT requests. An optional config can be passed as the |
| * last argument. |
| * |
| * ```js |
| * $http.get('/someUrl', config).then(successCallback, errorCallback); |
| * $http.post('/someUrl', data, config).then(successCallback, errorCallback); |
| * ``` |
| * |
| * Complete list of shortcut methods: |
| * |
| * - {@link ng.$http#get $http.get} |
| * - {@link ng.$http#head $http.head} |
| * - {@link ng.$http#post $http.post} |
| * - {@link ng.$http#put $http.put} |
| * - {@link ng.$http#delete $http.delete} |
| * - {@link ng.$http#jsonp $http.jsonp} |
| * - {@link ng.$http#patch $http.patch} |
| * |
| * |
| * ## Writing Unit Tests that use $http |
| * When unit testing (using {@link ngMock ngMock}), it is necessary to call |
| * {@link ngMock.$httpBackend#flush $httpBackend.flush()} to flush each pending |
| * request using trained responses. |
| * |
| * ``` |
| * $httpBackend.expectGET(...); |
| * $http.get(...); |
| * $httpBackend.flush(); |
| * ``` |
| * |
| * ## Deprecation Notice |
| * <div class="alert alert-danger"> |
| * The `$http` legacy promise methods `success` and `error` have been deprecated. |
| * Use the standard `then` method instead. |
| * If {@link $httpProvider#useLegacyPromiseExtensions `$httpProvider.useLegacyPromiseExtensions`} is set to |
| * `false` then these methods will throw {@link $http:legacy `$http/legacy`} error. |
| * </div> |
| * |
| * ## Setting HTTP Headers |
| * |
| * The $http service will automatically add certain HTTP headers to all requests. These defaults |
| * can be fully configured by accessing the `$httpProvider.defaults.headers` configuration |
| * object, which currently contains this default configuration: |
| * |
| * - `$httpProvider.defaults.headers.common` (headers that are common for all requests): |
| * - `Accept: application/json, text/plain, * / *` |
| * - `$httpProvider.defaults.headers.post`: (header defaults for POST requests) |
| * - `Content-Type: application/json` |
| * - `$httpProvider.defaults.headers.put` (header defaults for PUT requests) |
| * - `Content-Type: application/json` |
| * |
| * To add or overwrite these defaults, simply add or remove a property from these configuration |
| * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object |
| * with the lowercased HTTP method name as the key, e.g. |
| * `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }`. |
| * |
| * The defaults can also be set at runtime via the `$http.defaults` object in the same |
| * fashion. For example: |
| * |
| * ``` |
| * module.run(function($http) { |
| * $http.defaults.headers.common.Authorization = 'Basic YmVlcDpib29w' |
| * }); |
| * ``` |
| * |
| * In addition, you can supply a `headers` property in the config object passed when |
| * calling `$http(config)`, which overrides the defaults without changing them globally. |
| * |
| * To explicitly remove a header automatically added via $httpProvider.defaults.headers on a per request basis, |
| * Use the `headers` property, setting the desired header to `undefined`. For example: |
| * |
| * ```js |
| * var req = { |
| * method: 'POST', |
| * url: 'http://example.com', |
| * headers: { |
| * 'Content-Type': undefined |
| * }, |
| * data: { test: 'test' } |
| * } |
| * |
| * $http(req).then(function(){...}, function(){...}); |
| * ``` |
| * |
| * ## Transforming Requests and Responses |
| * |
| * Both requests and responses can be transformed using transformation functions: `transformRequest` |
| * and `transformResponse`. These properties can be a single function that returns |
| * the transformed value (`function(data, headersGetter, status)`) or an array of such transformation functions, |
| * which allows you to `push` or `unshift` a new transformation function into the transformation chain. |
| * |
| * ### Default Transformations |
| * |
| * The `$httpProvider` provider and `$http` service expose `defaults.transformRequest` and |
| * `defaults.transformResponse` properties. If a request does not provide its own transformations |
| * then these will be applied. |
| * |
| * You can augment or replace the default transformations by modifying these properties by adding to or |
| * replacing the array. |
| * |
| * Angular provides the following default transformations: |
| * |
| * Request transformations (`$httpProvider.defaults.transformRequest` and `$http.defaults.transformRequest`): |
| * |
| * - If the `data` property of the request configuration object contains an object, serialize it |
| * into JSON format. |
| * |
| * Response transformations (`$httpProvider.defaults.transformResponse` and `$http.defaults.transformResponse`): |
| * |
| * - If XSRF prefix is detected, strip it (see Security Considerations section below). |
| * - If JSON response is detected, deserialize it using a JSON parser. |
| * |
| * |
| * ### Overriding the Default Transformations Per Request |
| * |
| * If you wish override the request/response transformations only for a single request then provide |
| * `transformRequest` and/or `transformResponse` properties on the configuration object passed |
| * into `$http`. |
| * |
| * Note that if you provide these properties on the config object the default transformations will be |
| * overwritten. If you wish to augment the default transformations then you must include them in your |
| * local transformation array. |
| * |
| * The following code demonstrates adding a new response transformation to be run after the default response |
| * transformations have been run. |
| * |
| * ```js |
| * function appendTransform(defaults, transform) { |
| * |
| * // We can't guarantee that the default transformation is an array |
| * defaults = angular.isArray(defaults) ? defaults : [defaults]; |
| * |
| * // Append the new transformation to the defaults |
| * return defaults.concat(transform); |
| * } |
| * |
| * $http({ |
| * url: '...', |
| * method: 'GET', |
| * transformResponse: appendTransform($http.defaults.transformResponse, function(value) { |
| * return doTransform(value); |
| * }) |
| * }); |
| * ``` |
| * |
| * |
| * ## Caching |
| * |
| * To enable caching, set the request configuration `cache` property to `true` (to use default |
| * cache) or to a custom cache object (built with {@link ng.$cacheFactory `$cacheFactory`}). |
| * When the cache is enabled, `$http` stores the response from the server in the specified |
| * cache. The next time the same request is made, the response is served from the cache without |
| * sending a request to the server. |
| * |
| * Note that even if the response is served from cache, delivery of the data is asynchronous in |
| * the same way that real requests are. |
| * |
| * If there are multiple GET requests for the same URL that should be cached using the same |
| * cache, but the cache is not populated yet, only one request to the server will be made and |
| * the remaining requests will be fulfilled using the response from the first request. |
| * |
| * You can change the default cache to a new object (built with |
| * {@link ng.$cacheFactory `$cacheFactory`}) by updating the |
| * {@link ng.$http#defaults `$http.defaults.cache`} property. All requests who set |
| * their `cache` property to `true` will now use this cache object. |
| * |
| * If you set the default cache to `false` then only requests that specify their own custom |
| * cache object will be cached. |
| * |
| * ## Interceptors |
| * |
| * Before you start creating interceptors, be sure to understand the |
| * {@link ng.$q $q and deferred/promise APIs}. |
| * |
| * For purposes of global error handling, authentication, or any kind of synchronous or |
| * asynchronous pre-processing of request or postprocessing of responses, it is desirable to be |
| * able to intercept requests before they are handed to the server and |
| * responses before they are handed over to the application code that |
| * initiated these requests. The interceptors leverage the {@link ng.$q |
| * promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing. |
| * |
| * The interceptors are service factories that are registered with the `$httpProvider` by |
| * adding them to the `$httpProvider.interceptors` array. The factory is called and |
| * injected with dependencies (if specified) and returns the interceptor. |
| * |
| * There are two kinds of interceptors (and two kinds of rejection interceptors): |
| * |
| * * `request`: interceptors get called with a http {@link $http#usage config} object. The function is free to |
| * modify the `config` object or create a new one. The function needs to return the `config` |
| * object directly, or a promise containing the `config` or a new `config` object. |
| * * `requestError`: interceptor gets called when a previous interceptor threw an error or |
| * resolved with a rejection. |
| * * `response`: interceptors get called with http `response` object. The function is free to |
| * modify the `response` object or create a new one. The function needs to return the `response` |
| * object directly, or as a promise containing the `response` or a new `response` object. |
| * * `responseError`: interceptor gets called when a previous interceptor threw an error or |
| * resolved with a rejection. |
| * |
| * |
| * ```js |
| * // register the interceptor as a service |
| * $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) { |
| * return { |
| * // optional method |
| * 'request': function(config) { |
| * // do something on success |
| * return config; |
| * }, |
| * |
| * // optional method |
| * 'requestError': function(rejection) { |
| * // do something on error |
| * if (canRecover(rejection)) { |
| * return responseOrNewPromise |
| * } |
| * return $q.reject(rejection); |
| * }, |
| * |
| * |
| * |
| * // optional method |
| * 'response': function(response) { |
| * // do something on success |
| * return response; |
| * }, |
| * |
| * // optional method |
| * 'responseError': function(rejection) { |
| * // do something on error |
| * if (canRecover(rejection)) { |
| * return responseOrNewPromise |
| * } |
| * return $q.reject(rejection); |
| * } |
| * }; |
| * }); |
| * |
| * $httpProvider.interceptors.push('myHttpInterceptor'); |
| * |
| * |
| * // alternatively, register the interceptor via an anonymous factory |
| * $httpProvider.interceptors.push(function($q, dependency1, dependency2) { |
| * return { |
| * 'request': function(config) { |
| * // same as above |
| * }, |
| * |
| * 'response': function(response) { |
| * // same as above |
| * } |
| * }; |
| * }); |
| * ``` |
| * |
| * ## Security Considerations |
| * |
| * When designing web applications, consider security threats from: |
| * |
| * - [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx) |
| * - [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) |
| * |
| * Both server and the client must cooperate in order to eliminate these threats. Angular comes |
| * pre-configured with strategies that address these issues, but for this to work backend server |
| * cooperation is required. |
| * |
| * ### JSON Vulnerability Protection |
| * |
| * A [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx) |
| * allows third party website to turn your JSON resource URL into |
| * [JSONP](http://en.wikipedia.org/wiki/JSONP) request under some conditions. To |
| * counter this your server can prefix all JSON requests with following string `")]}',\n"`. |
| * Angular will automatically strip the prefix before processing it as JSON. |
| * |
| * For example if your server needs to return: |
| * ```js |
| * ['one','two'] |
| * ``` |
| * |
| * which is vulnerable to attack, your server can return: |
| * ```js |
| * )]}', |
| * ['one','two'] |
| * ``` |
| * |
| * Angular will strip the prefix, before processing the JSON. |
| * |
| * |
| * ### Cross Site Request Forgery (XSRF) Protection |
| * |
| * [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) is a technique by which |
| * an unauthorized site can gain your user's private data. Angular provides a mechanism |
| * to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie |
| * (by default, `XSRF-TOKEN`) and sets it as an HTTP header (`X-XSRF-TOKEN`). Since only |
| * JavaScript that runs on your domain could read the cookie, your server can be assured that |
| * the XHR came from JavaScript running on your domain. The header will not be set for |
| * cross-domain requests. |
| * |
| * To take advantage of this, your server needs to set a token in a JavaScript readable session |
| * cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the |
| * server can verify that the cookie matches `X-XSRF-TOKEN` HTTP header, and therefore be sure |
| * that only JavaScript running on your domain could have sent the request. The token must be |
| * unique for each user and must be verifiable by the server (to prevent the JavaScript from |
| * making up its own tokens). We recommend that the token is a digest of your site's |
| * authentication cookie with a [salt](https://en.wikipedia.org/wiki/Salt_(cryptography)) |
| * for added security. |
| * |
| * The name of the headers can be specified using the xsrfHeaderName and xsrfCookieName |
| * properties of either $httpProvider.defaults at config-time, $http.defaults at run-time, |
| * or the per-request config object. |
| * |
| * In order to prevent collisions in environments where multiple Angular apps share the |
| * same domain or subdomain, we recommend that each application uses unique cookie name. |
| * |
| * @param {object} config Object describing the request to be made and how it should be |
| * processed. The object has following properties: |
| * |
| * - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc) |
| * - **url** – `{string}` – Absolute or relative URL of the resource that is being requested. |
| * - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be serialized |
| * with the `paramSerializer` and appended as GET parameters. |
| * - **data** – `{string|Object}` – Data to be sent as the request message data. |
| * - **headers** – `{Object}` – Map of strings or functions which return strings representing |
| * HTTP headers to send to the server. If the return value of a function is null, the |
| * header will not be sent. Functions accept a config object as an argument. |
| * - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token. |
| * - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token. |
| * - **transformRequest** – |
| * `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` – |
| * transform function or an array of such functions. The transform function takes the http |
| * request body and headers and returns its transformed (typically serialized) version. |
| * See {@link ng.$http#overriding-the-default-transformations-per-request |
| * Overriding the Default Transformations} |
| * - **transformResponse** – |
| * `{function(data, headersGetter, status)|Array.<function(data, headersGetter, status)>}` – |
| * transform function or an array of such functions. The transform function takes the http |
| * response body, headers and status and returns its transformed (typically deserialized) version. |
| * See {@link ng.$http#overriding-the-default-transformations-per-request |
| * Overriding the Default TransformationjqLiks} |
| * - **paramSerializer** - `{string|function(Object<string,string>):string}` - A function used to |
| * prepare the string representation of request parameters (specified as an object). |
| * If specified as string, it is interpreted as function registered with the |
| * {@link $injector $injector}, which means you can create your own serializer |
| * by registering it as a {@link auto.$provide#service service}. |
| * The default serializer is the {@link $httpParamSerializer $httpParamSerializer}; |
| * alternatively, you can use the {@link $httpParamSerializerJQLike $httpParamSerializerJQLike} |
| * - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the |
| * GET request, otherwise if a cache instance built with |
| * {@link ng.$cacheFactory $cacheFactory}, this cache will be used for |
| * caching. |
| * - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise} |
| * that should abort the request when resolved. |
| * - **withCredentials** - `{boolean}` - whether to set the `withCredentials` flag on the |
| * XHR object. See [requests with credentials](https://developer.mozilla.org/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials) |
| * for more information. |
| * - **responseType** - `{string}` - see |
| * [XMLHttpRequest.responseType](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype). |
| * |
| * @returns {HttpPromise} Returns a {@link ng.$q `Promise}` that will be resolved to a response object |
| * when the request succeeds or fails. |
| * |
| * |
| * @property {Array.<Object>} pendingRequests Array of config objects for currently pending |
| * requests. This is primarily meant to be used for debugging purposes. |
| * |
| * |
| * @example |
| <example module="httpExample"> |
| <file name="index.html"> |
| <div ng-controller="FetchController"> |
| <select ng-model="method" aria-label="Request method"> |
| <option>GET</option> |
| <option>JSONP</option> |
| </select> |
| <input type="text" ng-model="url" size="80" aria-label="URL" /> |
| <button id="fetchbtn" ng-click="fetch()">fetch</button><br> |
| <button id="samplegetbtn" ng-click="updateModel('GET', 'http-hello.html')">Sample GET</button> |
| <button id="samplejsonpbtn" |
| ng-click="updateModel('JSONP', |
| 'https://angularjs.org/greet.php?callback=JSON_CALLBACK&name=Super%20Hero')"> |
| Sample JSONP |
| </button> |
| <button id="invalidjsonpbtn" |
| ng-click="updateModel('JSONP', 'https://angularjs.org/doesntexist&callback=JSON_CALLBACK')"> |
| Invalid JSONP |
| </button> |
| <pre>http status code: {{status}}</pre> |
| <pre>http response data: {{data}}</pre> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('httpExample', []) |
| .controller('FetchController', ['$scope', '$http', '$templateCache', |
| function($scope, $http, $templateCache) { |
| $scope.method = 'GET'; |
| $scope.url = 'http-hello.html'; |
| |
| $scope.fetch = function() { |
| $scope.code = null; |
| $scope.response = null; |
| |
| $http({method: $scope.method, url: $scope.url, cache: $templateCache}). |
| then(function(response) { |
| $scope.status = response.status; |
| $scope.data = response.data; |
| }, function(response) { |
| $scope.data = response.data || "Request failed"; |
| $scope.status = response.status; |
| }); |
| }; |
| |
| $scope.updateModel = function(method, url) { |
| $scope.method = method; |
| $scope.url = url; |
| }; |
| }]); |
| </file> |
| <file name="http-hello.html"> |
| Hello, $http! |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var status = element(by.binding('status')); |
| var data = element(by.binding('data')); |
| var fetchBtn = element(by.id('fetchbtn')); |
| var sampleGetBtn = element(by.id('samplegetbtn')); |
| var sampleJsonpBtn = element(by.id('samplejsonpbtn')); |
| var invalidJsonpBtn = element(by.id('invalidjsonpbtn')); |
| |
| it('should make an xhr GET request', function() { |
| sampleGetBtn.click(); |
| fetchBtn.click(); |
| expect(status.getText()).toMatch('200'); |
| expect(data.getText()).toMatch(/Hello, \$http!/); |
| }); |
| |
| // Commented out due to flakes. See https://github.com/angular/angular.js/issues/9185 |
| // it('should make a JSONP request to angularjs.org', function() { |
| // sampleJsonpBtn.click(); |
| // fetchBtn.click(); |
| // expect(status.getText()).toMatch('200'); |
| // expect(data.getText()).toMatch(/Super Hero!/); |
| // }); |
| |
| it('should make JSONP request to invalid URL and invoke the error handler', |
| function() { |
| invalidJsonpBtn.click(); |
| fetchBtn.click(); |
| expect(status.getText()).toMatch('0'); |
| expect(data.getText()).toMatch('Request failed'); |
| }); |
| </file> |
| </example> |
| */ |
| function $http(requestConfig) { |
| |
| if (!angular.isObject(requestConfig)) { |
| throw minErr('$http')('badreq', 'Http request configuration must be an object. Received: {0}', requestConfig); |
| } |
| |
| var config = extend({ |
| method: 'get', |
| transformRequest: defaults.transformRequest, |
| transformResponse: defaults.transformResponse, |
| paramSerializer: defaults.paramSerializer |
| }, requestConfig); |
| |
| config.headers = mergeHeaders(requestConfig); |
| config.method = uppercase(config.method); |
| config.paramSerializer = isString(config.paramSerializer) ? |
| $injector.get(config.paramSerializer) : config.paramSerializer; |
| |
| var serverRequest = function(config) { |
| var headers = config.headers; |
| var reqData = transformData(config.data, headersGetter(headers), undefined, config.transformRequest); |
| |
| // strip content-type if data is undefined |
| if (isUndefined(reqData)) { |
| forEach(headers, function(value, header) { |
| if (lowercase(header) === 'content-type') { |
| delete headers[header]; |
| } |
| }); |
| } |
| |
| if (isUndefined(config.withCredentials) && !isUndefined(defaults.withCredentials)) { |
| config.withCredentials = defaults.withCredentials; |
| } |
| |
| // send request |
| return sendReq(config, reqData).then(transformResponse, transformResponse); |
| }; |
| |
| var chain = [serverRequest, undefined]; |
| var promise = $q.when(config); |
| |
| // apply interceptors |
| forEach(reversedInterceptors, function(interceptor) { |
| if (interceptor.request || interceptor.requestError) { |
| chain.unshift(interceptor.request, interceptor.requestError); |
| } |
| if (interceptor.response || interceptor.responseError) { |
| chain.push(interceptor.response, interceptor.responseError); |
| } |
| }); |
| |
| while (chain.length) { |
| var thenFn = chain.shift(); |
| var rejectFn = chain.shift(); |
| |
| promise = promise.then(thenFn, rejectFn); |
| } |
| |
| if (useLegacyPromise) { |
| promise.success = function(fn) { |
| assertArgFn(fn, 'fn'); |
| |
| promise.then(function(response) { |
| fn(response.data, response.status, response.headers, config); |
| }); |
| return promise; |
| }; |
| |
| promise.error = function(fn) { |
| assertArgFn(fn, 'fn'); |
| |
| promise.then(null, function(response) { |
| fn(response.data, response.status, response.headers, config); |
| }); |
| return promise; |
| }; |
| } else { |
| promise.success = $httpMinErrLegacyFn('success'); |
| promise.error = $httpMinErrLegacyFn('error'); |
| } |
| |
| return promise; |
| |
| function transformResponse(response) { |
| // make a copy since the response must be cacheable |
| var resp = extend({}, response); |
| if (!response.data) { |
| resp.data = response.data; |
| } else { |
| resp.data = transformData(response.data, response.headers, response.status, config.transformResponse); |
| } |
| return (isSuccess(response.status)) |
| ? resp |
| : $q.reject(resp); |
| } |
| |
| function executeHeaderFns(headers, config) { |
| var headerContent, processedHeaders = {}; |
| |
| forEach(headers, function(headerFn, header) { |
| if (isFunction(headerFn)) { |
| headerContent = headerFn(config); |
| if (headerContent != null) { |
| processedHeaders[header] = headerContent; |
| } |
| } else { |
| processedHeaders[header] = headerFn; |
| } |
| }); |
| |
| return processedHeaders; |
| } |
| |
| function mergeHeaders(config) { |
| var defHeaders = defaults.headers, |
| reqHeaders = extend({}, config.headers), |
| defHeaderName, lowercaseDefHeaderName, reqHeaderName; |
| |
| defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)]); |
| |
| // using for-in instead of forEach to avoid unecessary iteration after header has been found |
| defaultHeadersIteration: |
| for (defHeaderName in defHeaders) { |
| lowercaseDefHeaderName = lowercase(defHeaderName); |
| |
| for (reqHeaderName in reqHeaders) { |
| if (lowercase(reqHeaderName) === lowercaseDefHeaderName) { |
| continue defaultHeadersIteration; |
| } |
| } |
| |
| reqHeaders[defHeaderName] = defHeaders[defHeaderName]; |
| } |
| |
| // execute if header value is a function for merged headers |
| return executeHeaderFns(reqHeaders, shallowCopy(config)); |
| } |
| } |
| |
| $http.pendingRequests = []; |
| |
| /** |
| * @ngdoc method |
| * @name $http#get |
| * |
| * @description |
| * Shortcut method to perform `GET` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $http#delete |
| * |
| * @description |
| * Shortcut method to perform `DELETE` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $http#head |
| * |
| * @description |
| * Shortcut method to perform `HEAD` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $http#jsonp |
| * |
| * @description |
| * Shortcut method to perform `JSONP` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request. |
| * The name of the callback should be the string `JSON_CALLBACK`. |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| createShortMethods('get', 'delete', 'head', 'jsonp'); |
| |
| /** |
| * @ngdoc method |
| * @name $http#post |
| * |
| * @description |
| * Shortcut method to perform `POST` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request |
| * @param {*} data Request content |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $http#put |
| * |
| * @description |
| * Shortcut method to perform `PUT` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request |
| * @param {*} data Request content |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $http#patch |
| * |
| * @description |
| * Shortcut method to perform `PATCH` request. |
| * |
| * @param {string} url Relative or absolute URL specifying the destination of the request |
| * @param {*} data Request content |
| * @param {Object=} config Optional configuration object |
| * @returns {HttpPromise} Future object |
| */ |
| createShortMethodsWithData('post', 'put', 'patch'); |
| |
| /** |
| * @ngdoc property |
| * @name $http#defaults |
| * |
| * @description |
| * Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of |
| * default headers, withCredentials as well as request and response transformations. |
| * |
| * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above. |
| */ |
| $http.defaults = defaults; |
| |
| |
| return $http; |
| |
| |
| function createShortMethods(names) { |
| forEach(arguments, function(name) { |
| $http[name] = function(url, config) { |
| return $http(extend({}, config || {}, { |
| method: name, |
| url: url |
| })); |
| }; |
| }); |
| } |
| |
| |
| function createShortMethodsWithData(name) { |
| forEach(arguments, function(name) { |
| $http[name] = function(url, data, config) { |
| return $http(extend({}, config || {}, { |
| method: name, |
| url: url, |
| data: data |
| })); |
| }; |
| }); |
| } |
| |
| |
| /** |
| * Makes the request. |
| * |
| * !!! ACCESSES CLOSURE VARS: |
| * $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests |
| */ |
| function sendReq(config, reqData) { |
| var deferred = $q.defer(), |
| promise = deferred.promise, |
| cache, |
| cachedResp, |
| reqHeaders = config.headers, |
| url = buildUrl(config.url, config.paramSerializer(config.params)); |
| |
| $http.pendingRequests.push(config); |
| promise.then(removePendingReq, removePendingReq); |
| |
| |
| if ((config.cache || defaults.cache) && config.cache !== false && |
| (config.method === 'GET' || config.method === 'JSONP')) { |
| cache = isObject(config.cache) ? config.cache |
| : isObject(defaults.cache) ? defaults.cache |
| : defaultCache; |
| } |
| |
| if (cache) { |
| cachedResp = cache.get(url); |
| if (isDefined(cachedResp)) { |
| if (isPromiseLike(cachedResp)) { |
| // cached request has already been sent, but there is no response yet |
| cachedResp.then(resolvePromiseWithResult, resolvePromiseWithResult); |
| } else { |
| // serving from cache |
| if (isArray(cachedResp)) { |
| resolvePromise(cachedResp[1], cachedResp[0], shallowCopy(cachedResp[2]), cachedResp[3]); |
| } else { |
| resolvePromise(cachedResp, 200, {}, 'OK'); |
| } |
| } |
| } else { |
| // put the promise for the non-transformed response into cache as a placeholder |
| cache.put(url, promise); |
| } |
| } |
| |
| |
| // if we won't have the response in cache, set the xsrf headers and |
| // send the request to the backend |
| if (isUndefined(cachedResp)) { |
| var xsrfValue = urlIsSameOrigin(config.url) |
| ? $$cookieReader()[config.xsrfCookieName || defaults.xsrfCookieName] |
| : undefined; |
| if (xsrfValue) { |
| reqHeaders[(config.xsrfHeaderName || defaults.xsrfHeaderName)] = xsrfValue; |
| } |
| |
| $httpBackend(config.method, url, reqData, done, reqHeaders, config.timeout, |
| config.withCredentials, config.responseType); |
| } |
| |
| return promise; |
| |
| |
| /** |
| * Callback registered to $httpBackend(): |
| * - caches the response if desired |
| * - resolves the raw $http promise |
| * - calls $apply |
| */ |
| function done(status, response, headersString, statusText) { |
| if (cache) { |
| if (isSuccess(status)) { |
| cache.put(url, [status, response, parseHeaders(headersString), statusText]); |
| } else { |
| // remove promise from the cache |
| cache.remove(url); |
| } |
| } |
| |
| function resolveHttpPromise() { |
| resolvePromise(response, status, headersString, statusText); |
| } |
| |
| if (useApplyAsync) { |
| $rootScope.$applyAsync(resolveHttpPromise); |
| } else { |
| resolveHttpPromise(); |
| if (!$rootScope.$$phase) $rootScope.$apply(); |
| } |
| } |
| |
| |
| /** |
| * Resolves the raw $http promise. |
| */ |
| function resolvePromise(response, status, headers, statusText) { |
| //status: HTTP response status code, 0, -1 (aborted by timeout / promise) |
| status = status >= -1 ? status : 0; |
| |
| (isSuccess(status) ? deferred.resolve : deferred.reject)({ |
| data: response, |
| status: status, |
| headers: headersGetter(headers), |
| config: config, |
| statusText: statusText |
| }); |
| } |
| |
| function resolvePromiseWithResult(result) { |
| resolvePromise(result.data, result.status, shallowCopy(result.headers()), result.statusText); |
| } |
| |
| function removePendingReq() { |
| var idx = $http.pendingRequests.indexOf(config); |
| if (idx !== -1) $http.pendingRequests.splice(idx, 1); |
| } |
| } |
| |
| |
| function buildUrl(url, serializedParams) { |
| if (serializedParams.length > 0) { |
| url += ((url.indexOf('?') == -1) ? '?' : '&') + serializedParams; |
| } |
| return url; |
| } |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $xhrFactory |
| * |
| * @description |
| * Factory function used to create XMLHttpRequest objects. |
| * |
| * Replace or decorate this service to create your own custom XMLHttpRequest objects. |
| * |
| * ``` |
| * angular.module('myApp', []) |
| * .factory('$xhrFactory', function() { |
| * return function createXhr(method, url) { |
| * return new window.XMLHttpRequest({mozSystem: true}); |
| * }; |
| * }); |
| * ``` |
| * |
| * @param {string} method HTTP method of the request (GET, POST, PUT, ..) |
| * @param {string} url URL of the request. |
| */ |
| function $xhrFactoryProvider() { |
| this.$get = function() { |
| return function createXhr() { |
| return new window.XMLHttpRequest(); |
| }; |
| }; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $httpBackend |
| * @requires $window |
| * @requires $document |
| * @requires $xhrFactory |
| * |
| * @description |
| * HTTP backend used by the {@link ng.$http service} that delegates to |
| * XMLHttpRequest object or JSONP and deals with browser incompatibilities. |
| * |
| * You should never need to use this service directly, instead use the higher-level abstractions: |
| * {@link ng.$http $http} or {@link ngResource.$resource $resource}. |
| * |
| * During testing this implementation is swapped with {@link ngMock.$httpBackend mock |
| * $httpBackend} which can be trained with responses. |
| */ |
| function $HttpBackendProvider() { |
| this.$get = ['$browser', '$window', '$document', '$xhrFactory', function($browser, $window, $document, $xhrFactory) { |
| return createHttpBackend($browser, $xhrFactory, $browser.defer, $window.angular.callbacks, $document[0]); |
| }]; |
| } |
| |
| function createHttpBackend($browser, createXhr, $browserDefer, callbacks, rawDocument) { |
| // TODO(vojta): fix the signature |
| return function(method, url, post, callback, headers, timeout, withCredentials, responseType) { |
| $browser.$$incOutstandingRequestCount(); |
| url = url || $browser.url(); |
| |
| if (lowercase(method) == 'jsonp') { |
| var callbackId = '_' + (callbacks.counter++).toString(36); |
| callbacks[callbackId] = function(data) { |
| callbacks[callbackId].data = data; |
| callbacks[callbackId].called = true; |
| }; |
| |
| var jsonpDone = jsonpReq(url.replace('JSON_CALLBACK', 'angular.callbacks.' + callbackId), |
| callbackId, function(status, text) { |
| completeRequest(callback, status, callbacks[callbackId].data, "", text); |
| callbacks[callbackId] = noop; |
| }); |
| } else { |
| |
| var xhr = createXhr(method, url); |
| |
| xhr.open(method, url, true); |
| forEach(headers, function(value, key) { |
| if (isDefined(value)) { |
| xhr.setRequestHeader(key, value); |
| } |
| }); |
| |
| xhr.onload = function requestLoaded() { |
| var statusText = xhr.statusText || ''; |
| |
| // responseText is the old-school way of retrieving response (supported by IE9) |
| // response/responseType properties were introduced in XHR Level2 spec (supported by IE10) |
| var response = ('response' in xhr) ? xhr.response : xhr.responseText; |
| |
| // normalize IE9 bug (http://bugs.jquery.com/ticket/1450) |
| var status = xhr.status === 1223 ? 204 : xhr.status; |
| |
| // fix status code when it is 0 (0 status is undocumented). |
| // Occurs when accessing file resources or on Android 4.1 stock browser |
| // while retrieving files from application cache. |
| if (status === 0) { |
| status = response ? 200 : urlResolve(url).protocol == 'file' ? 404 : 0; |
| } |
| |
| completeRequest(callback, |
| status, |
| response, |
| xhr.getAllResponseHeaders(), |
| statusText); |
| }; |
| |
| var requestError = function() { |
| // The response is always empty |
| // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error |
| completeRequest(callback, -1, null, null, ''); |
| }; |
| |
| xhr.onerror = requestError; |
| xhr.onabort = requestError; |
| |
| if (withCredentials) { |
| xhr.withCredentials = true; |
| } |
| |
| if (responseType) { |
| try { |
| xhr.responseType = responseType; |
| } catch (e) { |
| // WebKit added support for the json responseType value on 09/03/2013 |
| // https://bugs.webkit.org/show_bug.cgi?id=73648. Versions of Safari prior to 7 are |
| // known to throw when setting the value "json" as the response type. Other older |
| // browsers implementing the responseType |
| // |
| // The json response type can be ignored if not supported, because JSON payloads are |
| // parsed on the client-side regardless. |
| if (responseType !== 'json') { |
| throw e; |
| } |
| } |
| } |
| |
| xhr.send(isUndefined(post) ? null : post); |
| } |
| |
| if (timeout > 0) { |
| var timeoutId = $browserDefer(timeoutRequest, timeout); |
| } else if (isPromiseLike(timeout)) { |
| timeout.then(timeoutRequest); |
| } |
| |
| |
| function timeoutRequest() { |
| jsonpDone && jsonpDone(); |
| xhr && xhr.abort(); |
| } |
| |
| function completeRequest(callback, status, response, headersString, statusText) { |
| // cancel timeout and subsequent timeout promise resolution |
| if (isDefined(timeoutId)) { |
| $browserDefer.cancel(timeoutId); |
| } |
| jsonpDone = xhr = null; |
| |
| callback(status, response, headersString, statusText); |
| $browser.$$completeOutstandingRequest(noop); |
| } |
| }; |
| |
| function jsonpReq(url, callbackId, done) { |
| // we can't use jQuery/jqLite here because jQuery does crazy stuff with script elements, e.g.: |
| // - fetches local scripts via XHR and evals them |
| // - adds and immediately removes script elements from the document |
| var script = rawDocument.createElement('script'), callback = null; |
| script.type = "text/javascript"; |
| script.src = url; |
| script.async = true; |
| |
| callback = function(event) { |
| removeEventListenerFn(script, "load", callback); |
| removeEventListenerFn(script, "error", callback); |
| rawDocument.body.removeChild(script); |
| script = null; |
| var status = -1; |
| var text = "unknown"; |
| |
| if (event) { |
| if (event.type === "load" && !callbacks[callbackId].called) { |
| event = { type: "error" }; |
| } |
| text = event.type; |
| status = event.type === "error" ? 404 : 200; |
| } |
| |
| if (done) { |
| done(status, text); |
| } |
| }; |
| |
| addEventListenerFn(script, "load", callback); |
| addEventListenerFn(script, "error", callback); |
| rawDocument.body.appendChild(script); |
| return callback; |
| } |
| } |
| |
| var $interpolateMinErr = angular.$interpolateMinErr = minErr('$interpolate'); |
| $interpolateMinErr.throwNoconcat = function(text) { |
| throw $interpolateMinErr('noconcat', |
| "Error while interpolating: {0}\nStrict Contextual Escaping disallows " + |
| "interpolations that concatenate multiple expressions when a trusted value is " + |
| "required. See http://docs.angularjs.org/api/ng.$sce", text); |
| }; |
| |
| $interpolateMinErr.interr = function(text, err) { |
| return $interpolateMinErr('interr', "Can't interpolate: {0}\n{1}", text, err.toString()); |
| }; |
| |
| /** |
| * @ngdoc provider |
| * @name $interpolateProvider |
| * |
| * @description |
| * |
| * Used for configuring the interpolation markup. Defaults to `{{` and `}}`. |
| * |
| * @example |
| <example module="customInterpolationApp"> |
| <file name="index.html"> |
| <script> |
| var customInterpolationApp = angular.module('customInterpolationApp', []); |
| |
| customInterpolationApp.config(function($interpolateProvider) { |
| $interpolateProvider.startSymbol('//'); |
| $interpolateProvider.endSymbol('//'); |
| }); |
| |
| |
| customInterpolationApp.controller('DemoController', function() { |
| this.label = "This binding is brought you by // interpolation symbols."; |
| }); |
| </script> |
| <div ng-app="App" ng-controller="DemoController as demo"> |
| //demo.label// |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should interpolate binding with custom symbols', function() { |
| expect(element(by.binding('demo.label')).getText()).toBe('This binding is brought you by // interpolation symbols.'); |
| }); |
| </file> |
| </example> |
| */ |
| function $InterpolateProvider() { |
| var startSymbol = '{{'; |
| var endSymbol = '}}'; |
| |
| /** |
| * @ngdoc method |
| * @name $interpolateProvider#startSymbol |
| * @description |
| * Symbol to denote start of expression in the interpolated string. Defaults to `{{`. |
| * |
| * @param {string=} value new value to set the starting symbol to. |
| * @returns {string|self} Returns the symbol when used as getter and self if used as setter. |
| */ |
| this.startSymbol = function(value) { |
| if (value) { |
| startSymbol = value; |
| return this; |
| } else { |
| return startSymbol; |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $interpolateProvider#endSymbol |
| * @description |
| * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`. |
| * |
| * @param {string=} value new value to set the ending symbol to. |
| * @returns {string|self} Returns the symbol when used as getter and self if used as setter. |
| */ |
| this.endSymbol = function(value) { |
| if (value) { |
| endSymbol = value; |
| return this; |
| } else { |
| return endSymbol; |
| } |
| }; |
| |
| |
| this.$get = ['$parse', '$exceptionHandler', '$sce', function($parse, $exceptionHandler, $sce) { |
| var startSymbolLength = startSymbol.length, |
| endSymbolLength = endSymbol.length, |
| escapedStartRegexp = new RegExp(startSymbol.replace(/./g, escape), 'g'), |
| escapedEndRegexp = new RegExp(endSymbol.replace(/./g, escape), 'g'); |
| |
| function escape(ch) { |
| return '\\\\\\' + ch; |
| } |
| |
| function unescapeText(text) { |
| return text.replace(escapedStartRegexp, startSymbol). |
| replace(escapedEndRegexp, endSymbol); |
| } |
| |
| function stringify(value) { |
| if (value == null) { // null || undefined |
| return ''; |
| } |
| switch (typeof value) { |
| case 'string': |
| break; |
| case 'number': |
| value = '' + value; |
| break; |
| default: |
| value = toJson(value); |
| } |
| |
| return value; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $interpolate |
| * @kind function |
| * |
| * @requires $parse |
| * @requires $sce |
| * |
| * @description |
| * |
| * Compiles a string with markup into an interpolation function. This service is used by the |
| * HTML {@link ng.$compile $compile} service for data binding. See |
| * {@link ng.$interpolateProvider $interpolateProvider} for configuring the |
| * interpolation markup. |
| * |
| * |
| * ```js |
| * var $interpolate = ...; // injected |
| * var exp = $interpolate('Hello {{name | uppercase}}!'); |
| * expect(exp({name:'Angular'})).toEqual('Hello ANGULAR!'); |
| * ``` |
| * |
| * `$interpolate` takes an optional fourth argument, `allOrNothing`. If `allOrNothing` is |
| * `true`, the interpolation function will return `undefined` unless all embedded expressions |
| * evaluate to a value other than `undefined`. |
| * |
| * ```js |
| * var $interpolate = ...; // injected |
| * var context = {greeting: 'Hello', name: undefined }; |
| * |
| * // default "forgiving" mode |
| * var exp = $interpolate('{{greeting}} {{name}}!'); |
| * expect(exp(context)).toEqual('Hello !'); |
| * |
| * // "allOrNothing" mode |
| * exp = $interpolate('{{greeting}} {{name}}!', false, null, true); |
| * expect(exp(context)).toBeUndefined(); |
| * context.name = 'Angular'; |
| * expect(exp(context)).toEqual('Hello Angular!'); |
| * ``` |
| * |
| * `allOrNothing` is useful for interpolating URLs. `ngSrc` and `ngSrcset` use this behavior. |
| * |
| * ####Escaped Interpolation |
| * $interpolate provides a mechanism for escaping interpolation markers. Start and end markers |
| * can be escaped by preceding each of their characters with a REVERSE SOLIDUS U+005C (backslash). |
| * It will be rendered as a regular start/end marker, and will not be interpreted as an expression |
| * or binding. |
| * |
| * This enables web-servers to prevent script injection attacks and defacing attacks, to some |
| * degree, while also enabling code examples to work without relying on the |
| * {@link ng.directive:ngNonBindable ngNonBindable} directive. |
| * |
| * **For security purposes, it is strongly encouraged that web servers escape user-supplied data, |
| * replacing angle brackets (<, >) with &lt; and &gt; respectively, and replacing all |
| * interpolation start/end markers with their escaped counterparts.** |
| * |
| * Escaped interpolation markers are only replaced with the actual interpolation markers in rendered |
| * output when the $interpolate service processes the text. So, for HTML elements interpolated |
| * by {@link ng.$compile $compile}, or otherwise interpolated with the `mustHaveExpression` parameter |
| * set to `true`, the interpolated text must contain an unescaped interpolation expression. As such, |
| * this is typically useful only when user-data is used in rendering a template from the server, or |
| * when otherwise untrusted data is used by a directive. |
| * |
| * <example> |
| * <file name="index.html"> |
| * <div ng-init="username='A user'"> |
| * <p ng-init="apptitle='Escaping demo'">{{apptitle}}: \{\{ username = "defaced value"; \}\} |
| * </p> |
| * <p><strong>{{username}}</strong> attempts to inject code which will deface the |
| * application, but fails to accomplish their task, because the server has correctly |
| * escaped the interpolation start/end markers with REVERSE SOLIDUS U+005C (backslash) |
| * characters.</p> |
| * <p>Instead, the result of the attempted script injection is visible, and can be removed |
| * from the database by an administrator.</p> |
| * </div> |
| * </file> |
| * </example> |
| * |
| * @param {string} text The text with markup to interpolate. |
| * @param {boolean=} mustHaveExpression if set to true then the interpolation string must have |
| * embedded expression in order to return an interpolation function. Strings with no |
| * embedded expression will return null for the interpolation function. |
| * @param {string=} trustedContext when provided, the returned function passes the interpolated |
| * result through {@link ng.$sce#getTrusted $sce.getTrusted(interpolatedResult, |
| * trustedContext)} before returning it. Refer to the {@link ng.$sce $sce} service that |
| * provides Strict Contextual Escaping for details. |
| * @param {boolean=} allOrNothing if `true`, then the returned function returns undefined |
| * unless all embedded expressions evaluate to a value other than `undefined`. |
| * @returns {function(context)} an interpolation function which is used to compute the |
| * interpolated string. The function has these parameters: |
| * |
| * - `context`: evaluation context for all expressions embedded in the interpolated text |
| */ |
| function $interpolate(text, mustHaveExpression, trustedContext, allOrNothing) { |
| allOrNothing = !!allOrNothing; |
| var startIndex, |
| endIndex, |
| index = 0, |
| expressions = [], |
| parseFns = [], |
| textLength = text.length, |
| exp, |
| concat = [], |
| expressionPositions = []; |
| |
| while (index < textLength) { |
| if (((startIndex = text.indexOf(startSymbol, index)) != -1) && |
| ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1)) { |
| if (index !== startIndex) { |
| concat.push(unescapeText(text.substring(index, startIndex))); |
| } |
| exp = text.substring(startIndex + startSymbolLength, endIndex); |
| expressions.push(exp); |
| parseFns.push($parse(exp, parseStringifyInterceptor)); |
| index = endIndex + endSymbolLength; |
| expressionPositions.push(concat.length); |
| concat.push(''); |
| } else { |
| // we did not find an interpolation, so we have to add the remainder to the separators array |
| if (index !== textLength) { |
| concat.push(unescapeText(text.substring(index))); |
| } |
| break; |
| } |
| } |
| |
| // Concatenating expressions makes it hard to reason about whether some combination of |
| // concatenated values are unsafe to use and could easily lead to XSS. By requiring that a |
| // single expression be used for iframe[src], object[src], etc., we ensure that the value |
| // that's used is assigned or constructed by some JS code somewhere that is more testable or |
| // make it obvious that you bound the value to some user controlled value. This helps reduce |
| // the load when auditing for XSS issues. |
| if (trustedContext && concat.length > 1) { |
| $interpolateMinErr.throwNoconcat(text); |
| } |
| |
| if (!mustHaveExpression || expressions.length) { |
| var compute = function(values) { |
| for (var i = 0, ii = expressions.length; i < ii; i++) { |
| if (allOrNothing && isUndefined(values[i])) return; |
| concat[expressionPositions[i]] = values[i]; |
| } |
| return concat.join(''); |
| }; |
| |
| var getValue = function(value) { |
| return trustedContext ? |
| $sce.getTrusted(trustedContext, value) : |
| $sce.valueOf(value); |
| }; |
| |
| return extend(function interpolationFn(context) { |
| var i = 0; |
| var ii = expressions.length; |
| var values = new Array(ii); |
| |
| try { |
| for (; i < ii; i++) { |
| values[i] = parseFns[i](context); |
| } |
| |
| return compute(values); |
| } catch (err) { |
| $exceptionHandler($interpolateMinErr.interr(text, err)); |
| } |
| |
| }, { |
| // all of these properties are undocumented for now |
| exp: text, //just for compatibility with regular watchers created via $watch |
| expressions: expressions, |
| $$watchDelegate: function(scope, listener) { |
| var lastValue; |
| return scope.$watchGroup(parseFns, function interpolateFnWatcher(values, oldValues) { |
| var currValue = compute(values); |
| if (isFunction(listener)) { |
| listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope); |
| } |
| lastValue = currValue; |
| }); |
| } |
| }); |
| } |
| |
| function parseStringifyInterceptor(value) { |
| try { |
| value = getValue(value); |
| return allOrNothing && !isDefined(value) ? value : stringify(value); |
| } catch (err) { |
| $exceptionHandler($interpolateMinErr.interr(text, err)); |
| } |
| } |
| } |
| |
| |
| /** |
| * @ngdoc method |
| * @name $interpolate#startSymbol |
| * @description |
| * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`. |
| * |
| * Use {@link ng.$interpolateProvider#startSymbol `$interpolateProvider.startSymbol`} to change |
| * the symbol. |
| * |
| * @returns {string} start symbol. |
| */ |
| $interpolate.startSymbol = function() { |
| return startSymbol; |
| }; |
| |
| |
| /** |
| * @ngdoc method |
| * @name $interpolate#endSymbol |
| * @description |
| * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`. |
| * |
| * Use {@link ng.$interpolateProvider#endSymbol `$interpolateProvider.endSymbol`} to change |
| * the symbol. |
| * |
| * @returns {string} end symbol. |
| */ |
| $interpolate.endSymbol = function() { |
| return endSymbol; |
| }; |
| |
| return $interpolate; |
| }]; |
| } |
| |
| function $IntervalProvider() { |
| this.$get = ['$rootScope', '$window', '$q', '$$q', |
| function($rootScope, $window, $q, $$q) { |
| var intervals = {}; |
| |
| |
| /** |
| * @ngdoc service |
| * @name $interval |
| * |
| * @description |
| * Angular's wrapper for `window.setInterval`. The `fn` function is executed every `delay` |
| * milliseconds. |
| * |
| * The return value of registering an interval function is a promise. This promise will be |
| * notified upon each tick of the interval, and will be resolved after `count` iterations, or |
| * run indefinitely if `count` is not defined. The value of the notification will be the |
| * number of iterations that have run. |
| * To cancel an interval, call `$interval.cancel(promise)`. |
| * |
| * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to |
| * move forward by `millis` milliseconds and trigger any functions scheduled to run in that |
| * time. |
| * |
| * <div class="alert alert-warning"> |
| * **Note**: Intervals created by this service must be explicitly destroyed when you are finished |
| * with them. In particular they are not automatically destroyed when a controller's scope or a |
| * directive's element are destroyed. |
| * You should take this into consideration and make sure to always cancel the interval at the |
| * appropriate moment. See the example below for more details on how and when to do this. |
| * </div> |
| * |
| * @param {function()} fn A function that should be called repeatedly. |
| * @param {number} delay Number of milliseconds between each function call. |
| * @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat |
| * indefinitely. |
| * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise |
| * will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block. |
| * @param {...*=} Pass additional parameters to the executed function. |
| * @returns {promise} A promise which will be notified on each iteration. |
| * |
| * @example |
| * <example module="intervalExample"> |
| * <file name="index.html"> |
| * <script> |
| * angular.module('intervalExample', []) |
| * .controller('ExampleController', ['$scope', '$interval', |
| * function($scope, $interval) { |
| * $scope.format = 'M/d/yy h:mm:ss a'; |
| * $scope.blood_1 = 100; |
| * $scope.blood_2 = 120; |
| * |
| * var stop; |
| * $scope.fight = function() { |
| * // Don't start a new fight if we are already fighting |
| * if ( angular.isDefined(stop) ) return; |
| * |
| * stop = $interval(function() { |
| * if ($scope.blood_1 > 0 && $scope.blood_2 > 0) { |
| * $scope.blood_1 = $scope.blood_1 - 3; |
| * $scope.blood_2 = $scope.blood_2 - 4; |
| * } else { |
| * $scope.stopFight(); |
| * } |
| * }, 100); |
| * }; |
| * |
| * $scope.stopFight = function() { |
| * if (angular.isDefined(stop)) { |
| * $interval.cancel(stop); |
| * stop = undefined; |
| * } |
| * }; |
| * |
| * $scope.resetFight = function() { |
| * $scope.blood_1 = 100; |
| * $scope.blood_2 = 120; |
| * }; |
| * |
| * $scope.$on('$destroy', function() { |
| * // Make sure that the interval is destroyed too |
| * $scope.stopFight(); |
| * }); |
| * }]) |
| * // Register the 'myCurrentTime' directive factory method. |
| * // We inject $interval and dateFilter service since the factory method is DI. |
| * .directive('myCurrentTime', ['$interval', 'dateFilter', |
| * function($interval, dateFilter) { |
| * // return the directive link function. (compile function not needed) |
| * return function(scope, element, attrs) { |
| * var format, // date format |
| * stopTime; // so that we can cancel the time updates |
| * |
| * // used to update the UI |
| * function updateTime() { |
| * element.text(dateFilter(new Date(), format)); |
| * } |
| * |
| * // watch the expression, and update the UI on change. |
| * scope.$watch(attrs.myCurrentTime, function(value) { |
| * format = value; |
| * updateTime(); |
| * }); |
| * |
| * stopTime = $interval(updateTime, 1000); |
| * |
| * // listen on DOM destroy (removal) event, and cancel the next UI update |
| * // to prevent updating time after the DOM element was removed. |
| * element.on('$destroy', function() { |
| * $interval.cancel(stopTime); |
| * }); |
| * } |
| * }]); |
| * </script> |
| * |
| * <div> |
| * <div ng-controller="ExampleController"> |
| * <label>Date format: <input ng-model="format"></label> <hr/> |
| * Current time is: <span my-current-time="format"></span> |
| * <hr/> |
| * Blood 1 : <font color='red'>{{blood_1}}</font> |
| * Blood 2 : <font color='red'>{{blood_2}}</font> |
| * <button type="button" data-ng-click="fight()">Fight</button> |
| * <button type="button" data-ng-click="stopFight()">StopFight</button> |
| * <button type="button" data-ng-click="resetFight()">resetFight</button> |
| * </div> |
| * </div> |
| * |
| * </file> |
| * </example> |
| */ |
| function interval(fn, delay, count, invokeApply) { |
| var hasParams = arguments.length > 4, |
| args = hasParams ? sliceArgs(arguments, 4) : [], |
| setInterval = $window.setInterval, |
| clearInterval = $window.clearInterval, |
| iteration = 0, |
| skipApply = (isDefined(invokeApply) && !invokeApply), |
| deferred = (skipApply ? $$q : $q).defer(), |
| promise = deferred.promise; |
| |
| count = isDefined(count) ? count : 0; |
| |
| promise.then(null, null, (!hasParams) ? fn : function() { |
| fn.apply(null, args); |
| }); |
| |
| promise.$$intervalId = setInterval(function tick() { |
| deferred.notify(iteration++); |
| |
| if (count > 0 && iteration >= count) { |
| deferred.resolve(iteration); |
| clearInterval(promise.$$intervalId); |
| delete intervals[promise.$$intervalId]; |
| } |
| |
| if (!skipApply) $rootScope.$apply(); |
| |
| }, delay); |
| |
| intervals[promise.$$intervalId] = deferred; |
| |
| return promise; |
| } |
| |
| |
| /** |
| * @ngdoc method |
| * @name $interval#cancel |
| * |
| * @description |
| * Cancels a task associated with the `promise`. |
| * |
| * @param {Promise=} promise returned by the `$interval` function. |
| * @returns {boolean} Returns `true` if the task was successfully canceled. |
| */ |
| interval.cancel = function(promise) { |
| if (promise && promise.$$intervalId in intervals) { |
| intervals[promise.$$intervalId].reject('canceled'); |
| $window.clearInterval(promise.$$intervalId); |
| delete intervals[promise.$$intervalId]; |
| return true; |
| } |
| return false; |
| }; |
| |
| return interval; |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $locale |
| * |
| * @description |
| * $locale service provides localization rules for various Angular components. As of right now the |
| * only public api is: |
| * |
| * * `id` – `{string}` – locale id formatted as `languageId-countryId` (e.g. `en-us`) |
| */ |
| |
| var PATH_MATCH = /^([^\?#]*)(\?([^#]*))?(#(.*))?$/, |
| DEFAULT_PORTS = {'http': 80, 'https': 443, 'ftp': 21}; |
| var $locationMinErr = minErr('$location'); |
| |
| |
| /** |
| * Encode path using encodeUriSegment, ignoring forward slashes |
| * |
| * @param {string} path Path to encode |
| * @returns {string} |
| */ |
| function encodePath(path) { |
| var segments = path.split('/'), |
| i = segments.length; |
| |
| while (i--) { |
| segments[i] = encodeUriSegment(segments[i]); |
| } |
| |
| return segments.join('/'); |
| } |
| |
| function parseAbsoluteUrl(absoluteUrl, locationObj) { |
| var parsedUrl = urlResolve(absoluteUrl); |
| |
| locationObj.$$protocol = parsedUrl.protocol; |
| locationObj.$$host = parsedUrl.hostname; |
| locationObj.$$port = toInt(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null; |
| } |
| |
| |
| function parseAppUrl(relativeUrl, locationObj) { |
| var prefixed = (relativeUrl.charAt(0) !== '/'); |
| if (prefixed) { |
| relativeUrl = '/' + relativeUrl; |
| } |
| var match = urlResolve(relativeUrl); |
| locationObj.$$path = decodeURIComponent(prefixed && match.pathname.charAt(0) === '/' ? |
| match.pathname.substring(1) : match.pathname); |
| locationObj.$$search = parseKeyValue(match.search); |
| locationObj.$$hash = decodeURIComponent(match.hash); |
| |
| // make sure path starts with '/'; |
| if (locationObj.$$path && locationObj.$$path.charAt(0) != '/') { |
| locationObj.$$path = '/' + locationObj.$$path; |
| } |
| } |
| |
| |
| /** |
| * |
| * @param {string} begin |
| * @param {string} whole |
| * @returns {string} returns text from whole after begin or undefined if it does not begin with |
| * expected string. |
| */ |
| function beginsWith(begin, whole) { |
| if (whole.indexOf(begin) === 0) { |
| return whole.substr(begin.length); |
| } |
| } |
| |
| |
| function stripHash(url) { |
| var index = url.indexOf('#'); |
| return index == -1 ? url : url.substr(0, index); |
| } |
| |
| function trimEmptyHash(url) { |
| return url.replace(/(#.+)|#$/, '$1'); |
| } |
| |
| |
| function stripFile(url) { |
| return url.substr(0, stripHash(url).lastIndexOf('/') + 1); |
| } |
| |
| /* return the server only (scheme://host:port) */ |
| function serverBase(url) { |
| return url.substring(0, url.indexOf('/', url.indexOf('//') + 2)); |
| } |
| |
| |
| /** |
| * LocationHtml5Url represents an url |
| * This object is exposed as $location service when HTML5 mode is enabled and supported |
| * |
| * @constructor |
| * @param {string} appBase application base URL |
| * @param {string} appBaseNoFile application base URL stripped of any filename |
| * @param {string} basePrefix url path prefix |
| */ |
| function LocationHtml5Url(appBase, appBaseNoFile, basePrefix) { |
| this.$$html5 = true; |
| basePrefix = basePrefix || ''; |
| parseAbsoluteUrl(appBase, this); |
| |
| |
| /** |
| * Parse given html5 (regular) url string into properties |
| * @param {string} url HTML5 url |
| * @private |
| */ |
| this.$$parse = function(url) { |
| var pathUrl = beginsWith(appBaseNoFile, url); |
| if (!isString(pathUrl)) { |
| throw $locationMinErr('ipthprfx', 'Invalid url "{0}", missing path prefix "{1}".', url, |
| appBaseNoFile); |
| } |
| |
| parseAppUrl(pathUrl, this); |
| |
| if (!this.$$path) { |
| this.$$path = '/'; |
| } |
| |
| this.$$compose(); |
| }; |
| |
| /** |
| * Compose url and update `absUrl` property |
| * @private |
| */ |
| this.$$compose = function() { |
| var search = toKeyValue(this.$$search), |
| hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : ''; |
| |
| this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash; |
| this.$$absUrl = appBaseNoFile + this.$$url.substr(1); // first char is always '/' |
| }; |
| |
| this.$$parseLinkUrl = function(url, relHref) { |
| if (relHref && relHref[0] === '#') { |
| // special case for links to hash fragments: |
| // keep the old url and only replace the hash fragment |
| this.hash(relHref.slice(1)); |
| return true; |
| } |
| var appUrl, prevAppUrl; |
| var rewrittenUrl; |
| |
| if (isDefined(appUrl = beginsWith(appBase, url))) { |
| prevAppUrl = appUrl; |
| if (isDefined(appUrl = beginsWith(basePrefix, appUrl))) { |
| rewrittenUrl = appBaseNoFile + (beginsWith('/', appUrl) || appUrl); |
| } else { |
| rewrittenUrl = appBase + prevAppUrl; |
| } |
| } else if (isDefined(appUrl = beginsWith(appBaseNoFile, url))) { |
| rewrittenUrl = appBaseNoFile + appUrl; |
| } else if (appBaseNoFile == url + '/') { |
| rewrittenUrl = appBaseNoFile; |
| } |
| if (rewrittenUrl) { |
| this.$$parse(rewrittenUrl); |
| } |
| return !!rewrittenUrl; |
| }; |
| } |
| |
| |
| /** |
| * LocationHashbangUrl represents url |
| * This object is exposed as $location service when developer doesn't opt into html5 mode. |
| * It also serves as the base class for html5 mode fallback on legacy browsers. |
| * |
| * @constructor |
| * @param {string} appBase application base URL |
| * @param {string} appBaseNoFile application base URL stripped of any filename |
| * @param {string} hashPrefix hashbang prefix |
| */ |
| function LocationHashbangUrl(appBase, appBaseNoFile, hashPrefix) { |
| |
| parseAbsoluteUrl(appBase, this); |
| |
| |
| /** |
| * Parse given hashbang url into properties |
| * @param {string} url Hashbang url |
| * @private |
| */ |
| this.$$parse = function(url) { |
| var withoutBaseUrl = beginsWith(appBase, url) || beginsWith(appBaseNoFile, url); |
| var withoutHashUrl; |
| |
| if (!isUndefined(withoutBaseUrl) && withoutBaseUrl.charAt(0) === '#') { |
| |
| // The rest of the url starts with a hash so we have |
| // got either a hashbang path or a plain hash fragment |
| withoutHashUrl = beginsWith(hashPrefix, withoutBaseUrl); |
| if (isUndefined(withoutHashUrl)) { |
| // There was no hashbang prefix so we just have a hash fragment |
| withoutHashUrl = withoutBaseUrl; |
| } |
| |
| } else { |
| // There was no hashbang path nor hash fragment: |
| // If we are in HTML5 mode we use what is left as the path; |
| // Otherwise we ignore what is left |
| if (this.$$html5) { |
| withoutHashUrl = withoutBaseUrl; |
| } else { |
| withoutHashUrl = ''; |
| if (isUndefined(withoutBaseUrl)) { |
| appBase = url; |
| this.replace(); |
| } |
| } |
| } |
| |
| parseAppUrl(withoutHashUrl, this); |
| |
| this.$$path = removeWindowsDriveName(this.$$path, withoutHashUrl, appBase); |
| |
| this.$$compose(); |
| |
| /* |
| * In Windows, on an anchor node on documents loaded from |
| * the filesystem, the browser will return a pathname |
| * prefixed with the drive name ('/C:/path') when a |
| * pathname without a drive is set: |
| * * a.setAttribute('href', '/foo') |
| * * a.pathname === '/C:/foo' //true |
| * |
| * Inside of Angular, we're always using pathnames that |
| * do not include drive names for routing. |
| */ |
| function removeWindowsDriveName(path, url, base) { |
| /* |
| Matches paths for file protocol on windows, |
| such as /C:/foo/bar, and captures only /foo/bar. |
| */ |
| var windowsFilePathExp = /^\/[A-Z]:(\/.*)/; |
| |
| var firstPathSegmentMatch; |
| |
| //Get the relative path from the input URL. |
| if (url.indexOf(base) === 0) { |
| url = url.replace(base, ''); |
| } |
| |
| // The input URL intentionally contains a first path segment that ends with a colon. |
| if (windowsFilePathExp.exec(url)) { |
| return path; |
| } |
| |
| firstPathSegmentMatch = windowsFilePathExp.exec(path); |
| return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path; |
| } |
| }; |
| |
| /** |
| * Compose hashbang url and update `absUrl` property |
| * @private |
| */ |
| this.$$compose = function() { |
| var search = toKeyValue(this.$$search), |
| hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : ''; |
| |
| this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash; |
| this.$$absUrl = appBase + (this.$$url ? hashPrefix + this.$$url : ''); |
| }; |
| |
| this.$$parseLinkUrl = function(url, relHref) { |
| if (stripHash(appBase) == stripHash(url)) { |
| this.$$parse(url); |
| return true; |
| } |
| return false; |
| }; |
| } |
| |
| |
| /** |
| * LocationHashbangUrl represents url |
| * This object is exposed as $location service when html5 history api is enabled but the browser |
| * does not support it. |
| * |
| * @constructor |
| * @param {string} appBase application base URL |
| * @param {string} appBaseNoFile application base URL stripped of any filename |
| * @param {string} hashPrefix hashbang prefix |
| */ |
| function LocationHashbangInHtml5Url(appBase, appBaseNoFile, hashPrefix) { |
| this.$$html5 = true; |
| LocationHashbangUrl.apply(this, arguments); |
| |
| this.$$parseLinkUrl = function(url, relHref) { |
| if (relHref && relHref[0] === '#') { |
| // special case for links to hash fragments: |
| // keep the old url and only replace the hash fragment |
| this.hash(relHref.slice(1)); |
| return true; |
| } |
| |
| var rewrittenUrl; |
| var appUrl; |
| |
| if (appBase == stripHash(url)) { |
| rewrittenUrl = url; |
| } else if ((appUrl = beginsWith(appBaseNoFile, url))) { |
| rewrittenUrl = appBase + hashPrefix + appUrl; |
| } else if (appBaseNoFile === url + '/') { |
| rewrittenUrl = appBaseNoFile; |
| } |
| if (rewrittenUrl) { |
| this.$$parse(rewrittenUrl); |
| } |
| return !!rewrittenUrl; |
| }; |
| |
| this.$$compose = function() { |
| var search = toKeyValue(this.$$search), |
| hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : ''; |
| |
| this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash; |
| // include hashPrefix in $$absUrl when $$url is empty so IE9 does not reload page because of removal of '#' |
| this.$$absUrl = appBase + hashPrefix + this.$$url; |
| }; |
| |
| } |
| |
| |
| var locationPrototype = { |
| |
| /** |
| * Are we in html5 mode? |
| * @private |
| */ |
| $$html5: false, |
| |
| /** |
| * Has any change been replacing? |
| * @private |
| */ |
| $$replace: false, |
| |
| /** |
| * @ngdoc method |
| * @name $location#absUrl |
| * |
| * @description |
| * This method is getter only. |
| * |
| * Return full url representation with all segments encoded according to rules specified in |
| * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt). |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var absUrl = $location.absUrl(); |
| * // => "http://example.com/#/some/path?foo=bar&baz=xoxo" |
| * ``` |
| * |
| * @return {string} full url |
| */ |
| absUrl: locationGetter('$$absUrl'), |
| |
| /** |
| * @ngdoc method |
| * @name $location#url |
| * |
| * @description |
| * This method is getter / setter. |
| * |
| * Return url (e.g. `/path?a=b#hash`) when called without any parameter. |
| * |
| * Change path, search and hash, when called with parameter and return `$location`. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var url = $location.url(); |
| * // => "/some/path?foo=bar&baz=xoxo" |
| * ``` |
| * |
| * @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`) |
| * @return {string} url |
| */ |
| url: function(url) { |
| if (isUndefined(url)) { |
| return this.$$url; |
| } |
| |
| var match = PATH_MATCH.exec(url); |
| if (match[1] || url === '') this.path(decodeURIComponent(match[1])); |
| if (match[2] || match[1] || url === '') this.search(match[3] || ''); |
| this.hash(match[5] || ''); |
| |
| return this; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $location#protocol |
| * |
| * @description |
| * This method is getter only. |
| * |
| * Return protocol of current url. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var protocol = $location.protocol(); |
| * // => "http" |
| * ``` |
| * |
| * @return {string} protocol of current url |
| */ |
| protocol: locationGetter('$$protocol'), |
| |
| /** |
| * @ngdoc method |
| * @name $location#host |
| * |
| * @description |
| * This method is getter only. |
| * |
| * Return host of current url. |
| * |
| * Note: compared to the non-angular version `location.host` which returns `hostname:port`, this returns the `hostname` portion only. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var host = $location.host(); |
| * // => "example.com" |
| * |
| * // given url http://user:password@example.com:8080/#/some/path?foo=bar&baz=xoxo |
| * host = $location.host(); |
| * // => "example.com" |
| * host = location.host; |
| * // => "example.com:8080" |
| * ``` |
| * |
| * @return {string} host of current url. |
| */ |
| host: locationGetter('$$host'), |
| |
| /** |
| * @ngdoc method |
| * @name $location#port |
| * |
| * @description |
| * This method is getter only. |
| * |
| * Return port of current url. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var port = $location.port(); |
| * // => 80 |
| * ``` |
| * |
| * @return {Number} port |
| */ |
| port: locationGetter('$$port'), |
| |
| /** |
| * @ngdoc method |
| * @name $location#path |
| * |
| * @description |
| * This method is getter / setter. |
| * |
| * Return path of current url when called without any parameter. |
| * |
| * Change path when called with parameter and return `$location`. |
| * |
| * Note: Path should always begin with forward slash (/), this method will add the forward slash |
| * if it is missing. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var path = $location.path(); |
| * // => "/some/path" |
| * ``` |
| * |
| * @param {(string|number)=} path New path |
| * @return {string} path |
| */ |
| path: locationGetterSetter('$$path', function(path) { |
| path = path !== null ? path.toString() : ''; |
| return path.charAt(0) == '/' ? path : '/' + path; |
| }), |
| |
| /** |
| * @ngdoc method |
| * @name $location#search |
| * |
| * @description |
| * This method is getter / setter. |
| * |
| * Return search part (as object) of current url when called without any parameter. |
| * |
| * Change search part when called with parameter and return `$location`. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo |
| * var searchObject = $location.search(); |
| * // => {foo: 'bar', baz: 'xoxo'} |
| * |
| * // set foo to 'yipee' |
| * $location.search('foo', 'yipee'); |
| * // $location.search() => {foo: 'yipee', baz: 'xoxo'} |
| * ``` |
| * |
| * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or |
| * hash object. |
| * |
| * When called with a single argument the method acts as a setter, setting the `search` component |
| * of `$location` to the specified value. |
| * |
| * If the argument is a hash object containing an array of values, these values will be encoded |
| * as duplicate search parameters in the url. |
| * |
| * @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number, then `paramValue` |
| * will override only a single search property. |
| * |
| * If `paramValue` is an array, it will override the property of the `search` component of |
| * `$location` specified via the first argument. |
| * |
| * If `paramValue` is `null`, the property specified via the first argument will be deleted. |
| * |
| * If `paramValue` is `true`, the property specified via the first argument will be added with no |
| * value nor trailing equal sign. |
| * |
| * @return {Object} If called with no arguments returns the parsed `search` object. If called with |
| * one or more arguments returns `$location` object itself. |
| */ |
| search: function(search, paramValue) { |
| switch (arguments.length) { |
| case 0: |
| return this.$$search; |
| case 1: |
| if (isString(search) || isNumber(search)) { |
| search = search.toString(); |
| this.$$search = parseKeyValue(search); |
| } else if (isObject(search)) { |
| search = copy(search, {}); |
| // remove object undefined or null properties |
| forEach(search, function(value, key) { |
| if (value == null) delete search[key]; |
| }); |
| |
| this.$$search = search; |
| } else { |
| throw $locationMinErr('isrcharg', |
| 'The first argument of the `$location#search()` call must be a string or an object.'); |
| } |
| break; |
| default: |
| if (isUndefined(paramValue) || paramValue === null) { |
| delete this.$$search[search]; |
| } else { |
| this.$$search[search] = paramValue; |
| } |
| } |
| |
| this.$$compose(); |
| return this; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $location#hash |
| * |
| * @description |
| * This method is getter / setter. |
| * |
| * Return hash fragment when called without any parameter. |
| * |
| * Change hash fragment when called with parameter and return `$location`. |
| * |
| * |
| * ```js |
| * // given url http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue |
| * var hash = $location.hash(); |
| * // => "hashValue" |
| * ``` |
| * |
| * @param {(string|number)=} hash New hash fragment |
| * @return {string} hash |
| */ |
| hash: locationGetterSetter('$$hash', function(hash) { |
| return hash !== null ? hash.toString() : ''; |
| }), |
| |
| /** |
| * @ngdoc method |
| * @name $location#replace |
| * |
| * @description |
| * If called, all changes to $location during current `$digest` will be replacing current history |
| * record, instead of adding new one. |
| */ |
| replace: function() { |
| this.$$replace = true; |
| return this; |
| } |
| }; |
| |
| forEach([LocationHashbangInHtml5Url, LocationHashbangUrl, LocationHtml5Url], function(Location) { |
| Location.prototype = Object.create(locationPrototype); |
| |
| /** |
| * @ngdoc method |
| * @name $location#state |
| * |
| * @description |
| * This method is getter / setter. |
| * |
| * Return the history state object when called without any parameter. |
| * |
| * Change the history state object when called with one parameter and return `$location`. |
| * The state object is later passed to `pushState` or `replaceState`. |
| * |
| * NOTE: This method is supported only in HTML5 mode and only in browsers supporting |
| * the HTML5 History API (i.e. methods `pushState` and `replaceState`). If you need to support |
| * older browsers (like IE9 or Android < 4.0), don't use this method. |
| * |
| * @param {object=} state State object for pushState or replaceState |
| * @return {object} state |
| */ |
| Location.prototype.state = function(state) { |
| if (!arguments.length) { |
| return this.$$state; |
| } |
| |
| if (Location !== LocationHtml5Url || !this.$$html5) { |
| throw $locationMinErr('nostate', 'History API state support is available only ' + |
| 'in HTML5 mode and only in browsers supporting HTML5 History API'); |
| } |
| // The user might modify `stateObject` after invoking `$location.state(stateObject)` |
| // but we're changing the $$state reference to $browser.state() during the $digest |
| // so the modification window is narrow. |
| this.$$state = isUndefined(state) ? null : state; |
| |
| return this; |
| }; |
| }); |
| |
| |
| function locationGetter(property) { |
| return function() { |
| return this[property]; |
| }; |
| } |
| |
| |
| function locationGetterSetter(property, preprocess) { |
| return function(value) { |
| if (isUndefined(value)) { |
| return this[property]; |
| } |
| |
| this[property] = preprocess(value); |
| this.$$compose(); |
| |
| return this; |
| }; |
| } |
| |
| |
| /** |
| * @ngdoc service |
| * @name $location |
| * |
| * @requires $rootElement |
| * |
| * @description |
| * The $location service parses the URL in the browser address bar (based on the |
| * [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL |
| * available to your application. Changes to the URL in the address bar are reflected into |
| * $location service and changes to $location are reflected into the browser address bar. |
| * |
| * **The $location service:** |
| * |
| * - Exposes the current URL in the browser address bar, so you can |
| * - Watch and observe the URL. |
| * - Change the URL. |
| * - Synchronizes the URL with the browser when the user |
| * - Changes the address bar. |
| * - Clicks the back or forward button (or clicks a History link). |
| * - Clicks on a link. |
| * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash). |
| * |
| * For more information see {@link guide/$location Developer Guide: Using $location} |
| */ |
| |
| /** |
| * @ngdoc provider |
| * @name $locationProvider |
| * @description |
| * Use the `$locationProvider` to configure how the application deep linking paths are stored. |
| */ |
| function $LocationProvider() { |
| var hashPrefix = '', |
| html5Mode = { |
| enabled: false, |
| requireBase: true, |
| rewriteLinks: true |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $locationProvider#hashPrefix |
| * @description |
| * @param {string=} prefix Prefix for hash part (containing path and search) |
| * @returns {*} current value if used as getter or itself (chaining) if used as setter |
| */ |
| this.hashPrefix = function(prefix) { |
| if (isDefined(prefix)) { |
| hashPrefix = prefix; |
| return this; |
| } else { |
| return hashPrefix; |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $locationProvider#html5Mode |
| * @description |
| * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value. |
| * If object, sets `enabled`, `requireBase` and `rewriteLinks` to respective values. Supported |
| * properties: |
| * - **enabled** – `{boolean}` – (default: false) If true, will rely on `history.pushState` to |
| * change urls where supported. Will fall back to hash-prefixed paths in browsers that do not |
| * support `pushState`. |
| * - **requireBase** - `{boolean}` - (default: `true`) When html5Mode is enabled, specifies |
| * whether or not a <base> tag is required to be present. If `enabled` and `requireBase` are |
| * true, and a base tag is not present, an error will be thrown when `$location` is injected. |
| * See the {@link guide/$location $location guide for more information} |
| * - **rewriteLinks** - `{boolean}` - (default: `true`) When html5Mode is enabled, |
| * enables/disables url rewriting for relative links. |
| * |
| * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter |
| */ |
| this.html5Mode = function(mode) { |
| if (isBoolean(mode)) { |
| html5Mode.enabled = mode; |
| return this; |
| } else if (isObject(mode)) { |
| |
| if (isBoolean(mode.enabled)) { |
| html5Mode.enabled = mode.enabled; |
| } |
| |
| if (isBoolean(mode.requireBase)) { |
| html5Mode.requireBase = mode.requireBase; |
| } |
| |
| if (isBoolean(mode.rewriteLinks)) { |
| html5Mode.rewriteLinks = mode.rewriteLinks; |
| } |
| |
| return this; |
| } else { |
| return html5Mode; |
| } |
| }; |
| |
| /** |
| * @ngdoc event |
| * @name $location#$locationChangeStart |
| * @eventType broadcast on root scope |
| * @description |
| * Broadcasted before a URL will change. |
| * |
| * This change can be prevented by calling |
| * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more |
| * details about event object. Upon successful change |
| * {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired. |
| * |
| * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when |
| * the browser supports the HTML5 History API. |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {string} newUrl New URL |
| * @param {string=} oldUrl URL that was before it was changed. |
| * @param {string=} newState New history state object |
| * @param {string=} oldState History state object that was before it was changed. |
| */ |
| |
| /** |
| * @ngdoc event |
| * @name $location#$locationChangeSuccess |
| * @eventType broadcast on root scope |
| * @description |
| * Broadcasted after a URL was changed. |
| * |
| * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when |
| * the browser supports the HTML5 History API. |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {string} newUrl New URL |
| * @param {string=} oldUrl URL that was before it was changed. |
| * @param {string=} newState New history state object |
| * @param {string=} oldState History state object that was before it was changed. |
| */ |
| |
| this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement', '$window', |
| function($rootScope, $browser, $sniffer, $rootElement, $window) { |
| var $location, |
| LocationMode, |
| baseHref = $browser.baseHref(), // if base[href] is undefined, it defaults to '' |
| initialUrl = $browser.url(), |
| appBase; |
| |
| if (html5Mode.enabled) { |
| if (!baseHref && html5Mode.requireBase) { |
| throw $locationMinErr('nobase', |
| "$location in HTML5 mode requires a <base> tag to be present!"); |
| } |
| appBase = serverBase(initialUrl) + (baseHref || '/'); |
| LocationMode = $sniffer.history ? LocationHtml5Url : LocationHashbangInHtml5Url; |
| } else { |
| appBase = stripHash(initialUrl); |
| LocationMode = LocationHashbangUrl; |
| } |
| var appBaseNoFile = stripFile(appBase); |
| |
| $location = new LocationMode(appBase, appBaseNoFile, '#' + hashPrefix); |
| $location.$$parseLinkUrl(initialUrl, initialUrl); |
| |
| $location.$$state = $browser.state(); |
| |
| var IGNORE_URI_REGEXP = /^\s*(javascript|mailto):/i; |
| |
| function setBrowserUrlWithFallback(url, replace, state) { |
| var oldUrl = $location.url(); |
| var oldState = $location.$$state; |
| try { |
| $browser.url(url, replace, state); |
| |
| // Make sure $location.state() returns referentially identical (not just deeply equal) |
| // state object; this makes possible quick checking if the state changed in the digest |
| // loop. Checking deep equality would be too expensive. |
| $location.$$state = $browser.state(); |
| } catch (e) { |
| // Restore old values if pushState fails |
| $location.url(oldUrl); |
| $location.$$state = oldState; |
| |
| throw e; |
| } |
| } |
| |
| $rootElement.on('click', function(event) { |
| // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser) |
| // currently we open nice url link and redirect then |
| |
| if (!html5Mode.rewriteLinks || event.ctrlKey || event.metaKey || event.shiftKey || event.which == 2 || event.button == 2) return; |
| |
| var elm = jqLite(event.target); |
| |
| // traverse the DOM up to find first A tag |
| while (nodeName_(elm[0]) !== 'a') { |
| // ignore rewriting if no A tag (reached root element, or no parent - removed from document) |
| if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return; |
| } |
| |
| var absHref = elm.prop('href'); |
| // get the actual href attribute - see |
| // http://msdn.microsoft.com/en-us/library/ie/dd347148(v=vs.85).aspx |
| var relHref = elm.attr('href') || elm.attr('xlink:href'); |
| |
| if (isObject(absHref) && absHref.toString() === '[object SVGAnimatedString]') { |
| // SVGAnimatedString.animVal should be identical to SVGAnimatedString.baseVal, unless during |
| // an animation. |
| absHref = urlResolve(absHref.animVal).href; |
| } |
| |
| // Ignore when url is started with javascript: or mailto: |
| if (IGNORE_URI_REGEXP.test(absHref)) return; |
| |
| if (absHref && !elm.attr('target') && !event.isDefaultPrevented()) { |
| if ($location.$$parseLinkUrl(absHref, relHref)) { |
| // We do a preventDefault for all urls that are part of the angular application, |
| // in html5mode and also without, so that we are able to abort navigation without |
| // getting double entries in the location history. |
| event.preventDefault(); |
| // update location manually |
| if ($location.absUrl() != $browser.url()) { |
| $rootScope.$apply(); |
| // hack to work around FF6 bug 684208 when scenario runner clicks on links |
| $window.angular['ff-684208-preventDefault'] = true; |
| } |
| } |
| } |
| }); |
| |
| |
| // rewrite hashbang url <> html5 url |
| if (trimEmptyHash($location.absUrl()) != trimEmptyHash(initialUrl)) { |
| $browser.url($location.absUrl(), true); |
| } |
| |
| var initializing = true; |
| |
| // update $location when $browser url changes |
| $browser.onUrlChange(function(newUrl, newState) { |
| |
| if (isUndefined(beginsWith(appBaseNoFile, newUrl))) { |
| // If we are navigating outside of the app then force a reload |
| $window.location.href = newUrl; |
| return; |
| } |
| |
| $rootScope.$evalAsync(function() { |
| var oldUrl = $location.absUrl(); |
| var oldState = $location.$$state; |
| var defaultPrevented; |
| |
| $location.$$parse(newUrl); |
| $location.$$state = newState; |
| |
| defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl, |
| newState, oldState).defaultPrevented; |
| |
| // if the location was changed by a `$locationChangeStart` handler then stop |
| // processing this location change |
| if ($location.absUrl() !== newUrl) return; |
| |
| if (defaultPrevented) { |
| $location.$$parse(oldUrl); |
| $location.$$state = oldState; |
| setBrowserUrlWithFallback(oldUrl, false, oldState); |
| } else { |
| initializing = false; |
| afterLocationChange(oldUrl, oldState); |
| } |
| }); |
| if (!$rootScope.$$phase) $rootScope.$digest(); |
| }); |
| |
| // update browser |
| $rootScope.$watch(function $locationWatch() { |
| var oldUrl = trimEmptyHash($browser.url()); |
| var newUrl = trimEmptyHash($location.absUrl()); |
| var oldState = $browser.state(); |
| var currentReplace = $location.$$replace; |
| var urlOrStateChanged = oldUrl !== newUrl || |
| ($location.$$html5 && $sniffer.history && oldState !== $location.$$state); |
| |
| if (initializing || urlOrStateChanged) { |
| initializing = false; |
| |
| $rootScope.$evalAsync(function() { |
| var newUrl = $location.absUrl(); |
| var defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl, |
| $location.$$state, oldState).defaultPrevented; |
| |
| // if the location was changed by a `$locationChangeStart` handler then stop |
| // processing this location change |
| if ($location.absUrl() !== newUrl) return; |
| |
| if (defaultPrevented) { |
| $location.$$parse(oldUrl); |
| $location.$$state = oldState; |
| } else { |
| if (urlOrStateChanged) { |
| setBrowserUrlWithFallback(newUrl, currentReplace, |
| oldState === $location.$$state ? null : $location.$$state); |
| } |
| afterLocationChange(oldUrl, oldState); |
| } |
| }); |
| } |
| |
| $location.$$replace = false; |
| |
| // we don't need to return anything because $evalAsync will make the digest loop dirty when |
| // there is a change |
| }); |
| |
| return $location; |
| |
| function afterLocationChange(oldUrl, oldState) { |
| $rootScope.$broadcast('$locationChangeSuccess', $location.absUrl(), oldUrl, |
| $location.$$state, oldState); |
| } |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $log |
| * @requires $window |
| * |
| * @description |
| * Simple service for logging. Default implementation safely writes the message |
| * into the browser's console (if present). |
| * |
| * The main purpose of this service is to simplify debugging and troubleshooting. |
| * |
| * The default is to log `debug` messages. You can use |
| * {@link ng.$logProvider ng.$logProvider#debugEnabled} to change this. |
| * |
| * @example |
| <example module="logExample"> |
| <file name="script.js"> |
| angular.module('logExample', []) |
| .controller('LogController', ['$scope', '$log', function($scope, $log) { |
| $scope.$log = $log; |
| $scope.message = 'Hello World!'; |
| }]); |
| </file> |
| <file name="index.html"> |
| <div ng-controller="LogController"> |
| <p>Reload this page with open console, enter text and hit the log button...</p> |
| <label>Message: |
| <input type="text" ng-model="message" /></label> |
| <button ng-click="$log.log(message)">log</button> |
| <button ng-click="$log.warn(message)">warn</button> |
| <button ng-click="$log.info(message)">info</button> |
| <button ng-click="$log.error(message)">error</button> |
| <button ng-click="$log.debug(message)">debug</button> |
| </div> |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc provider |
| * @name $logProvider |
| * @description |
| * Use the `$logProvider` to configure how the application logs messages |
| */ |
| function $LogProvider() { |
| var debug = true, |
| self = this; |
| |
| /** |
| * @ngdoc method |
| * @name $logProvider#debugEnabled |
| * @description |
| * @param {boolean=} flag enable or disable debug level messages |
| * @returns {*} current value if used as getter or itself (chaining) if used as setter |
| */ |
| this.debugEnabled = function(flag) { |
| if (isDefined(flag)) { |
| debug = flag; |
| return this; |
| } else { |
| return debug; |
| } |
| }; |
| |
| this.$get = ['$window', function($window) { |
| return { |
| /** |
| * @ngdoc method |
| * @name $log#log |
| * |
| * @description |
| * Write a log message |
| */ |
| log: consoleLog('log'), |
| |
| /** |
| * @ngdoc method |
| * @name $log#info |
| * |
| * @description |
| * Write an information message |
| */ |
| info: consoleLog('info'), |
| |
| /** |
| * @ngdoc method |
| * @name $log#warn |
| * |
| * @description |
| * Write a warning message |
| */ |
| warn: consoleLog('warn'), |
| |
| /** |
| * @ngdoc method |
| * @name $log#error |
| * |
| * @description |
| * Write an error message |
| */ |
| error: consoleLog('error'), |
| |
| /** |
| * @ngdoc method |
| * @name $log#debug |
| * |
| * @description |
| * Write a debug message |
| */ |
| debug: (function() { |
| var fn = consoleLog('debug'); |
| |
| return function() { |
| if (debug) { |
| fn.apply(self, arguments); |
| } |
| }; |
| }()) |
| }; |
| |
| function formatError(arg) { |
| if (arg instanceof Error) { |
| if (arg.stack) { |
| arg = (arg.message && arg.stack.indexOf(arg.message) === -1) |
| ? 'Error: ' + arg.message + '\n' + arg.stack |
| : arg.stack; |
| } else if (arg.sourceURL) { |
| arg = arg.message + '\n' + arg.sourceURL + ':' + arg.line; |
| } |
| } |
| return arg; |
| } |
| |
| function consoleLog(type) { |
| var console = $window.console || {}, |
| logFn = console[type] || console.log || noop, |
| hasApply = false; |
| |
| // Note: reading logFn.apply throws an error in IE11 in IE8 document mode. |
| // The reason behind this is that console.log has type "object" in IE8... |
| try { |
| hasApply = !!logFn.apply; |
| } catch (e) {} |
| |
| if (hasApply) { |
| return function() { |
| var args = []; |
| forEach(arguments, function(arg) { |
| args.push(formatError(arg)); |
| }); |
| return logFn.apply(console, args); |
| }; |
| } |
| |
| // we are IE which either doesn't have window.console => this is noop and we do nothing, |
| // or we are IE where console.log doesn't have apply so we log at least first 2 args |
| return function(arg1, arg2) { |
| logFn(arg1, arg2 == null ? '' : arg2); |
| }; |
| } |
| }]; |
| } |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Any commits to this file should be reviewed with security in mind. * |
| * Changes to this file can potentially create security vulnerabilities. * |
| * An approval from 2 Core members with history of modifying * |
| * this file is required. * |
| * * |
| * Does the change somehow allow for arbitrary javascript to be executed? * |
| * Or allows for someone to change the prototype of built-in objects? * |
| * Or gives undesired access to variables likes document or window? * |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| var $parseMinErr = minErr('$parse'); |
| |
| // Sandboxing Angular Expressions |
| // ------------------------------ |
| // Angular expressions are generally considered safe because these expressions only have direct |
| // access to `$scope` and locals. However, one can obtain the ability to execute arbitrary JS code by |
| // obtaining a reference to native JS functions such as the Function constructor. |
| // |
| // As an example, consider the following Angular expression: |
| // |
| // {}.toString.constructor('alert("evil JS code")') |
| // |
| // This sandboxing technique is not perfect and doesn't aim to be. The goal is to prevent exploits |
| // against the expression language, but not to prevent exploits that were enabled by exposing |
| // sensitive JavaScript or browser APIs on Scope. Exposing such objects on a Scope is never a good |
| // practice and therefore we are not even trying to protect against interaction with an object |
| // explicitly exposed in this way. |
| // |
| // In general, it is not possible to access a Window object from an angular expression unless a |
| // window or some DOM object that has a reference to window is published onto a Scope. |
| // Similarly we prevent invocations of function known to be dangerous, as well as assignments to |
| // native objects. |
| // |
| // See https://docs.angularjs.org/guide/security |
| |
| |
| function ensureSafeMemberName(name, fullExpression) { |
| if (name === "__defineGetter__" || name === "__defineSetter__" |
| || name === "__lookupGetter__" || name === "__lookupSetter__" |
| || name === "__proto__") { |
| throw $parseMinErr('isecfld', |
| 'Attempting to access a disallowed field in Angular expressions! ' |
| + 'Expression: {0}', fullExpression); |
| } |
| return name; |
| } |
| |
| function getStringValue(name, fullExpression) { |
| // From the JavaScript docs: |
| // Property names must be strings. This means that non-string objects cannot be used |
| // as keys in an object. Any non-string object, including a number, is typecasted |
| // into a string via the toString method. |
| // |
| // So, to ensure that we are checking the same `name` that JavaScript would use, |
| // we cast it to a string, if possible. |
| // Doing `name + ''` can cause a repl error if the result to `toString` is not a string, |
| // this is, this will handle objects that misbehave. |
| name = name + ''; |
| if (!isString(name)) { |
| throw $parseMinErr('iseccst', |
| 'Cannot convert object to primitive value! ' |
| + 'Expression: {0}', fullExpression); |
| } |
| return name; |
| } |
| |
| function ensureSafeObject(obj, fullExpression) { |
| // nifty check if obj is Function that is fast and works across iframes and other contexts |
| if (obj) { |
| if (obj.constructor === obj) { |
| throw $parseMinErr('isecfn', |
| 'Referencing Function in Angular expressions is disallowed! Expression: {0}', |
| fullExpression); |
| } else if (// isWindow(obj) |
| obj.window === obj) { |
| throw $parseMinErr('isecwindow', |
| 'Referencing the Window in Angular expressions is disallowed! Expression: {0}', |
| fullExpression); |
| } else if (// isElement(obj) |
| obj.children && (obj.nodeName || (obj.prop && obj.attr && obj.find))) { |
| throw $parseMinErr('isecdom', |
| 'Referencing DOM nodes in Angular expressions is disallowed! Expression: {0}', |
| fullExpression); |
| } else if (// block Object so that we can't get hold of dangerous Object.* methods |
| obj === Object) { |
| throw $parseMinErr('isecobj', |
| 'Referencing Object in Angular expressions is disallowed! Expression: {0}', |
| fullExpression); |
| } |
| } |
| return obj; |
| } |
| |
| var CALL = Function.prototype.call; |
| var APPLY = Function.prototype.apply; |
| var BIND = Function.prototype.bind; |
| |
| function ensureSafeFunction(obj, fullExpression) { |
| if (obj) { |
| if (obj.constructor === obj) { |
| throw $parseMinErr('isecfn', |
| 'Referencing Function in Angular expressions is disallowed! Expression: {0}', |
| fullExpression); |
| } else if (obj === CALL || obj === APPLY || obj === BIND) { |
| throw $parseMinErr('isecff', |
| 'Referencing call, apply or bind in Angular expressions is disallowed! Expression: {0}', |
| fullExpression); |
| } |
| } |
| } |
| |
| function ensureSafeAssignContext(obj, fullExpression) { |
| if (obj) { |
| if (obj === (0).constructor || obj === (false).constructor || obj === ''.constructor || |
| obj === {}.constructor || obj === [].constructor || obj === Function.constructor) { |
| throw $parseMinErr('isecaf', |
| 'Assigning to a constructor is disallowed! Expression: {0}', fullExpression); |
| } |
| } |
| } |
| |
| var OPERATORS = createMap(); |
| forEach('+ - * / % === !== == != < > <= >= && || ! = |'.split(' '), function(operator) { OPERATORS[operator] = true; }); |
| var ESCAPE = {"n":"\n", "f":"\f", "r":"\r", "t":"\t", "v":"\v", "'":"'", '"':'"'}; |
| |
| |
| ///////////////////////////////////////// |
| |
| |
| /** |
| * @constructor |
| */ |
| var Lexer = function(options) { |
| this.options = options; |
| }; |
| |
| Lexer.prototype = { |
| constructor: Lexer, |
| |
| lex: function(text) { |
| this.text = text; |
| this.index = 0; |
| this.tokens = []; |
| |
| while (this.index < this.text.length) { |
| var ch = this.text.charAt(this.index); |
| if (ch === '"' || ch === "'") { |
| this.readString(ch); |
| } else if (this.isNumber(ch) || ch === '.' && this.isNumber(this.peek())) { |
| this.readNumber(); |
| } else if (this.isIdent(ch)) { |
| this.readIdent(); |
| } else if (this.is(ch, '(){}[].,;:?')) { |
| this.tokens.push({index: this.index, text: ch}); |
| this.index++; |
| } else if (this.isWhitespace(ch)) { |
| this.index++; |
| } else { |
| var ch2 = ch + this.peek(); |
| var ch3 = ch2 + this.peek(2); |
| var op1 = OPERATORS[ch]; |
| var op2 = OPERATORS[ch2]; |
| var op3 = OPERATORS[ch3]; |
| if (op1 || op2 || op3) { |
| var token = op3 ? ch3 : (op2 ? ch2 : ch); |
| this.tokens.push({index: this.index, text: token, operator: true}); |
| this.index += token.length; |
| } else { |
| this.throwError('Unexpected next character ', this.index, this.index + 1); |
| } |
| } |
| } |
| return this.tokens; |
| }, |
| |
| is: function(ch, chars) { |
| return chars.indexOf(ch) !== -1; |
| }, |
| |
| peek: function(i) { |
| var num = i || 1; |
| return (this.index + num < this.text.length) ? this.text.charAt(this.index + num) : false; |
| }, |
| |
| isNumber: function(ch) { |
| return ('0' <= ch && ch <= '9') && typeof ch === "string"; |
| }, |
| |
| isWhitespace: function(ch) { |
| // IE treats non-breaking space as \u00A0 |
| return (ch === ' ' || ch === '\r' || ch === '\t' || |
| ch === '\n' || ch === '\v' || ch === '\u00A0'); |
| }, |
| |
| isIdent: function(ch) { |
| return ('a' <= ch && ch <= 'z' || |
| 'A' <= ch && ch <= 'Z' || |
| '_' === ch || ch === '$'); |
| }, |
| |
| isExpOperator: function(ch) { |
| return (ch === '-' || ch === '+' || this.isNumber(ch)); |
| }, |
| |
| throwError: function(error, start, end) { |
| end = end || this.index; |
| var colStr = (isDefined(start) |
| ? 's ' + start + '-' + this.index + ' [' + this.text.substring(start, end) + ']' |
| : ' ' + end); |
| throw $parseMinErr('lexerr', 'Lexer Error: {0} at column{1} in expression [{2}].', |
| error, colStr, this.text); |
| }, |
| |
| readNumber: function() { |
| var number = ''; |
| var start = this.index; |
| while (this.index < this.text.length) { |
| var ch = lowercase(this.text.charAt(this.index)); |
| if (ch == '.' || this.isNumber(ch)) { |
| number += ch; |
| } else { |
| var peekCh = this.peek(); |
| if (ch == 'e' && this.isExpOperator(peekCh)) { |
| number += ch; |
| } else if (this.isExpOperator(ch) && |
| peekCh && this.isNumber(peekCh) && |
| number.charAt(number.length - 1) == 'e') { |
| number += ch; |
| } else if (this.isExpOperator(ch) && |
| (!peekCh || !this.isNumber(peekCh)) && |
| number.charAt(number.length - 1) == 'e') { |
| this.throwError('Invalid exponent'); |
| } else { |
| break; |
| } |
| } |
| this.index++; |
| } |
| this.tokens.push({ |
| index: start, |
| text: number, |
| constant: true, |
| value: Number(number) |
| }); |
| }, |
| |
| readIdent: function() { |
| var start = this.index; |
| while (this.index < this.text.length) { |
| var ch = this.text.charAt(this.index); |
| if (!(this.isIdent(ch) || this.isNumber(ch))) { |
| break; |
| } |
| this.index++; |
| } |
| this.tokens.push({ |
| index: start, |
| text: this.text.slice(start, this.index), |
| identifier: true |
| }); |
| }, |
| |
| readString: function(quote) { |
| var start = this.index; |
| this.index++; |
| var string = ''; |
| var rawString = quote; |
| var escape = false; |
| while (this.index < this.text.length) { |
| var ch = this.text.charAt(this.index); |
| rawString += ch; |
| if (escape) { |
| if (ch === 'u') { |
| var hex = this.text.substring(this.index + 1, this.index + 5); |
| if (!hex.match(/[\da-f]{4}/i)) { |
| this.throwError('Invalid unicode escape [\\u' + hex + ']'); |
| } |
| this.index += 4; |
| string += String.fromCharCode(parseInt(hex, 16)); |
| } else { |
| var rep = ESCAPE[ch]; |
| string = string + (rep || ch); |
| } |
| escape = false; |
| } else if (ch === '\\') { |
| escape = true; |
| } else if (ch === quote) { |
| this.index++; |
| this.tokens.push({ |
| index: start, |
| text: rawString, |
| constant: true, |
| value: string |
| }); |
| return; |
| } else { |
| string += ch; |
| } |
| this.index++; |
| } |
| this.throwError('Unterminated quote', start); |
| } |
| }; |
| |
| var AST = function(lexer, options) { |
| this.lexer = lexer; |
| this.options = options; |
| }; |
| |
| AST.Program = 'Program'; |
| AST.ExpressionStatement = 'ExpressionStatement'; |
| AST.AssignmentExpression = 'AssignmentExpression'; |
| AST.ConditionalExpression = 'ConditionalExpression'; |
| AST.LogicalExpression = 'LogicalExpression'; |
| AST.BinaryExpression = 'BinaryExpression'; |
| AST.UnaryExpression = 'UnaryExpression'; |
| AST.CallExpression = 'CallExpression'; |
| AST.MemberExpression = 'MemberExpression'; |
| AST.Identifier = 'Identifier'; |
| AST.Literal = 'Literal'; |
| AST.ArrayExpression = 'ArrayExpression'; |
| AST.Property = 'Property'; |
| AST.ObjectExpression = 'ObjectExpression'; |
| AST.ThisExpression = 'ThisExpression'; |
| |
| // Internal use only |
| AST.NGValueParameter = 'NGValueParameter'; |
| |
| AST.prototype = { |
| ast: function(text) { |
| this.text = text; |
| this.tokens = this.lexer.lex(text); |
| |
| var value = this.program(); |
| |
| if (this.tokens.length !== 0) { |
| this.throwError('is an unexpected token', this.tokens[0]); |
| } |
| |
| return value; |
| }, |
| |
| program: function() { |
| var body = []; |
| while (true) { |
| if (this.tokens.length > 0 && !this.peek('}', ')', ';', ']')) |
| body.push(this.expressionStatement()); |
| if (!this.expect(';')) { |
| return { type: AST.Program, body: body}; |
| } |
| } |
| }, |
| |
| expressionStatement: function() { |
| return { type: AST.ExpressionStatement, expression: this.filterChain() }; |
| }, |
| |
| filterChain: function() { |
| var left = this.expression(); |
| var token; |
| while ((token = this.expect('|'))) { |
| left = this.filter(left); |
| } |
| return left; |
| }, |
| |
| expression: function() { |
| return this.assignment(); |
| }, |
| |
| assignment: function() { |
| var result = this.ternary(); |
| if (this.expect('=')) { |
| result = { type: AST.AssignmentExpression, left: result, right: this.assignment(), operator: '='}; |
| } |
| return result; |
| }, |
| |
| ternary: function() { |
| var test = this.logicalOR(); |
| var alternate; |
| var consequent; |
| if (this.expect('?')) { |
| alternate = this.expression(); |
| if (this.consume(':')) { |
| consequent = this.expression(); |
| return { type: AST.ConditionalExpression, test: test, alternate: alternate, consequent: consequent}; |
| } |
| } |
| return test; |
| }, |
| |
| logicalOR: function() { |
| var left = this.logicalAND(); |
| while (this.expect('||')) { |
| left = { type: AST.LogicalExpression, operator: '||', left: left, right: this.logicalAND() }; |
| } |
| return left; |
| }, |
| |
| logicalAND: function() { |
| var left = this.equality(); |
| while (this.expect('&&')) { |
| left = { type: AST.LogicalExpression, operator: '&&', left: left, right: this.equality()}; |
| } |
| return left; |
| }, |
| |
| equality: function() { |
| var left = this.relational(); |
| var token; |
| while ((token = this.expect('==','!=','===','!=='))) { |
| left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.relational() }; |
| } |
| return left; |
| }, |
| |
| relational: function() { |
| var left = this.additive(); |
| var token; |
| while ((token = this.expect('<', '>', '<=', '>='))) { |
| left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.additive() }; |
| } |
| return left; |
| }, |
| |
| additive: function() { |
| var left = this.multiplicative(); |
| var token; |
| while ((token = this.expect('+','-'))) { |
| left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.multiplicative() }; |
| } |
| return left; |
| }, |
| |
| multiplicative: function() { |
| var left = this.unary(); |
| var token; |
| while ((token = this.expect('*','/','%'))) { |
| left = { type: AST.BinaryExpression, operator: token.text, left: left, right: this.unary() }; |
| } |
| return left; |
| }, |
| |
| unary: function() { |
| var token; |
| if ((token = this.expect('+', '-', '!'))) { |
| return { type: AST.UnaryExpression, operator: token.text, prefix: true, argument: this.unary() }; |
| } else { |
| return this.primary(); |
| } |
| }, |
| |
| primary: function() { |
| var primary; |
| if (this.expect('(')) { |
| primary = this.filterChain(); |
| this.consume(')'); |
| } else if (this.expect('[')) { |
| primary = this.arrayDeclaration(); |
| } else if (this.expect('{')) { |
| primary = this.object(); |
| } else if (this.constants.hasOwnProperty(this.peek().text)) { |
| primary = copy(this.constants[this.consume().text]); |
| } else if (this.peek().identifier) { |
| primary = this.identifier(); |
| } else if (this.peek().constant) { |
| primary = this.constant(); |
| } else { |
| this.throwError('not a primary expression', this.peek()); |
| } |
| |
| var next; |
| while ((next = this.expect('(', '[', '.'))) { |
| if (next.text === '(') { |
| primary = {type: AST.CallExpression, callee: primary, arguments: this.parseArguments() }; |
| this.consume(')'); |
| } else if (next.text === '[') { |
| primary = { type: AST.MemberExpression, object: primary, property: this.expression(), computed: true }; |
| this.consume(']'); |
| } else if (next.text === '.') { |
| primary = { type: AST.MemberExpression, object: primary, property: this.identifier(), computed: false }; |
| } else { |
| this.throwError('IMPOSSIBLE'); |
| } |
| } |
| return primary; |
| }, |
| |
| filter: function(baseExpression) { |
| var args = [baseExpression]; |
| var result = {type: AST.CallExpression, callee: this.identifier(), arguments: args, filter: true}; |
| |
| while (this.expect(':')) { |
| args.push(this.expression()); |
| } |
| |
| return result; |
| }, |
| |
| parseArguments: function() { |
| var args = []; |
| if (this.peekToken().text !== ')') { |
| do { |
| args.push(this.expression()); |
| } while (this.expect(',')); |
| } |
| return args; |
| }, |
| |
| identifier: function() { |
| var token = this.consume(); |
| if (!token.identifier) { |
| this.throwError('is not a valid identifier', token); |
| } |
| return { type: AST.Identifier, name: token.text }; |
| }, |
| |
| constant: function() { |
| // TODO check that it is a constant |
| return { type: AST.Literal, value: this.consume().value }; |
| }, |
| |
| arrayDeclaration: function() { |
| var elements = []; |
| if (this.peekToken().text !== ']') { |
| do { |
| if (this.peek(']')) { |
| // Support trailing commas per ES5.1. |
| break; |
| } |
| elements.push(this.expression()); |
| } while (this.expect(',')); |
| } |
| this.consume(']'); |
| |
| return { type: AST.ArrayExpression, elements: elements }; |
| }, |
| |
| object: function() { |
| var properties = [], property; |
| if (this.peekToken().text !== '}') { |
| do { |
| if (this.peek('}')) { |
| // Support trailing commas per ES5.1. |
| break; |
| } |
| property = {type: AST.Property, kind: 'init'}; |
| if (this.peek().constant) { |
| property.key = this.constant(); |
| } else if (this.peek().identifier) { |
| property.key = this.identifier(); |
| } else { |
| this.throwError("invalid key", this.peek()); |
| } |
| this.consume(':'); |
| property.value = this.expression(); |
| properties.push(property); |
| } while (this.expect(',')); |
| } |
| this.consume('}'); |
| |
| return {type: AST.ObjectExpression, properties: properties }; |
| }, |
| |
| throwError: function(msg, token) { |
| throw $parseMinErr('syntax', |
| 'Syntax Error: Token \'{0}\' {1} at column {2} of the expression [{3}] starting at [{4}].', |
| token.text, msg, (token.index + 1), this.text, this.text.substring(token.index)); |
| }, |
| |
| consume: function(e1) { |
| if (this.tokens.length === 0) { |
| throw $parseMinErr('ueoe', 'Unexpected end of expression: {0}', this.text); |
| } |
| |
| var token = this.expect(e1); |
| if (!token) { |
| this.throwError('is unexpected, expecting [' + e1 + ']', this.peek()); |
| } |
| return token; |
| }, |
| |
| peekToken: function() { |
| if (this.tokens.length === 0) { |
| throw $parseMinErr('ueoe', 'Unexpected end of expression: {0}', this.text); |
| } |
| return this.tokens[0]; |
| }, |
| |
| peek: function(e1, e2, e3, e4) { |
| return this.peekAhead(0, e1, e2, e3, e4); |
| }, |
| |
| peekAhead: function(i, e1, e2, e3, e4) { |
| if (this.tokens.length > i) { |
| var token = this.tokens[i]; |
| var t = token.text; |
| if (t === e1 || t === e2 || t === e3 || t === e4 || |
| (!e1 && !e2 && !e3 && !e4)) { |
| return token; |
| } |
| } |
| return false; |
| }, |
| |
| expect: function(e1, e2, e3, e4) { |
| var token = this.peek(e1, e2, e3, e4); |
| if (token) { |
| this.tokens.shift(); |
| return token; |
| } |
| return false; |
| }, |
| |
| |
| /* `undefined` is not a constant, it is an identifier, |
| * but using it as an identifier is not supported |
| */ |
| constants: { |
| 'true': { type: AST.Literal, value: true }, |
| 'false': { type: AST.Literal, value: false }, |
| 'null': { type: AST.Literal, value: null }, |
| 'undefined': {type: AST.Literal, value: undefined }, |
| 'this': {type: AST.ThisExpression } |
| } |
| }; |
| |
| function ifDefined(v, d) { |
| return typeof v !== 'undefined' ? v : d; |
| } |
| |
| function plusFn(l, r) { |
| if (typeof l === 'undefined') return r; |
| if (typeof r === 'undefined') return l; |
| return l + r; |
| } |
| |
| function isStateless($filter, filterName) { |
| var fn = $filter(filterName); |
| return !fn.$stateful; |
| } |
| |
| function findConstantAndWatchExpressions(ast, $filter) { |
| var allConstants; |
| var argsToWatch; |
| switch (ast.type) { |
| case AST.Program: |
| allConstants = true; |
| forEach(ast.body, function(expr) { |
| findConstantAndWatchExpressions(expr.expression, $filter); |
| allConstants = allConstants && expr.expression.constant; |
| }); |
| ast.constant = allConstants; |
| break; |
| case AST.Literal: |
| ast.constant = true; |
| ast.toWatch = []; |
| break; |
| case AST.UnaryExpression: |
| findConstantAndWatchExpressions(ast.argument, $filter); |
| ast.constant = ast.argument.constant; |
| ast.toWatch = ast.argument.toWatch; |
| break; |
| case AST.BinaryExpression: |
| findConstantAndWatchExpressions(ast.left, $filter); |
| findConstantAndWatchExpressions(ast.right, $filter); |
| ast.constant = ast.left.constant && ast.right.constant; |
| ast.toWatch = ast.left.toWatch.concat(ast.right.toWatch); |
| break; |
| case AST.LogicalExpression: |
| findConstantAndWatchExpressions(ast.left, $filter); |
| findConstantAndWatchExpressions(ast.right, $filter); |
| ast.constant = ast.left.constant && ast.right.constant; |
| ast.toWatch = ast.constant ? [] : [ast]; |
| break; |
| case AST.ConditionalExpression: |
| findConstantAndWatchExpressions(ast.test, $filter); |
| findConstantAndWatchExpressions(ast.alternate, $filter); |
| findConstantAndWatchExpressions(ast.consequent, $filter); |
| ast.constant = ast.test.constant && ast.alternate.constant && ast.consequent.constant; |
| ast.toWatch = ast.constant ? [] : [ast]; |
| break; |
| case AST.Identifier: |
| ast.constant = false; |
| ast.toWatch = [ast]; |
| break; |
| case AST.MemberExpression: |
| findConstantAndWatchExpressions(ast.object, $filter); |
| if (ast.computed) { |
| findConstantAndWatchExpressions(ast.property, $filter); |
| } |
| ast.constant = ast.object.constant && (!ast.computed || ast.property.constant); |
| ast.toWatch = [ast]; |
| break; |
| case AST.CallExpression: |
| allConstants = ast.filter ? isStateless($filter, ast.callee.name) : false; |
| argsToWatch = []; |
| forEach(ast.arguments, function(expr) { |
| findConstantAndWatchExpressions(expr, $filter); |
| allConstants = allConstants && expr.constant; |
| if (!expr.constant) { |
| argsToWatch.push.apply(argsToWatch, expr.toWatch); |
| } |
| }); |
| ast.constant = allConstants; |
| ast.toWatch = ast.filter && isStateless($filter, ast.callee.name) ? argsToWatch : [ast]; |
| break; |
| case AST.AssignmentExpression: |
| findConstantAndWatchExpressions(ast.left, $filter); |
| findConstantAndWatchExpressions(ast.right, $filter); |
| ast.constant = ast.left.constant && ast.right.constant; |
| ast.toWatch = [ast]; |
| break; |
| case AST.ArrayExpression: |
| allConstants = true; |
| argsToWatch = []; |
| forEach(ast.elements, function(expr) { |
| findConstantAndWatchExpressions(expr, $filter); |
| allConstants = allConstants && expr.constant; |
| if (!expr.constant) { |
| argsToWatch.push.apply(argsToWatch, expr.toWatch); |
| } |
| }); |
| ast.constant = allConstants; |
| ast.toWatch = argsToWatch; |
| break; |
| case AST.ObjectExpression: |
| allConstants = true; |
| argsToWatch = []; |
| forEach(ast.properties, function(property) { |
| findConstantAndWatchExpressions(property.value, $filter); |
| allConstants = allConstants && property.value.constant; |
| if (!property.value.constant) { |
| argsToWatch.push.apply(argsToWatch, property.value.toWatch); |
| } |
| }); |
| ast.constant = allConstants; |
| ast.toWatch = argsToWatch; |
| break; |
| case AST.ThisExpression: |
| ast.constant = false; |
| ast.toWatch = []; |
| break; |
| } |
| } |
| |
| function getInputs(body) { |
| if (body.length != 1) return; |
| var lastExpression = body[0].expression; |
| var candidate = lastExpression.toWatch; |
| if (candidate.length !== 1) return candidate; |
| return candidate[0] !== lastExpression ? candidate : undefined; |
| } |
| |
| function isAssignable(ast) { |
| return ast.type === AST.Identifier || ast.type === AST.MemberExpression; |
| } |
| |
| function assignableAST(ast) { |
| if (ast.body.length === 1 && isAssignable(ast.body[0].expression)) { |
| return {type: AST.AssignmentExpression, left: ast.body[0].expression, right: {type: AST.NGValueParameter}, operator: '='}; |
| } |
| } |
| |
| function isLiteral(ast) { |
| return ast.body.length === 0 || |
| ast.body.length === 1 && ( |
| ast.body[0].expression.type === AST.Literal || |
| ast.body[0].expression.type === AST.ArrayExpression || |
| ast.body[0].expression.type === AST.ObjectExpression); |
| } |
| |
| function isConstant(ast) { |
| return ast.constant; |
| } |
| |
| function ASTCompiler(astBuilder, $filter) { |
| this.astBuilder = astBuilder; |
| this.$filter = $filter; |
| } |
| |
| ASTCompiler.prototype = { |
| compile: function(expression, expensiveChecks) { |
| var self = this; |
| var ast = this.astBuilder.ast(expression); |
| this.state = { |
| nextId: 0, |
| filters: {}, |
| expensiveChecks: expensiveChecks, |
| fn: {vars: [], body: [], own: {}}, |
| assign: {vars: [], body: [], own: {}}, |
| inputs: [] |
| }; |
| findConstantAndWatchExpressions(ast, self.$filter); |
| var extra = ''; |
| var assignable; |
| this.stage = 'assign'; |
| if ((assignable = assignableAST(ast))) { |
| this.state.computing = 'assign'; |
| var result = this.nextId(); |
| this.recurse(assignable, result); |
| this.return_(result); |
| extra = 'fn.assign=' + this.generateFunction('assign', 's,v,l'); |
| } |
| var toWatch = getInputs(ast.body); |
| self.stage = 'inputs'; |
| forEach(toWatch, function(watch, key) { |
| var fnKey = 'fn' + key; |
| self.state[fnKey] = {vars: [], body: [], own: {}}; |
| self.state.computing = fnKey; |
| var intoId = self.nextId(); |
| self.recurse(watch, intoId); |
| self.return_(intoId); |
| self.state.inputs.push(fnKey); |
| watch.watchId = key; |
| }); |
| this.state.computing = 'fn'; |
| this.stage = 'main'; |
| this.recurse(ast); |
| var fnString = |
| // The build and minification steps remove the string "use strict" from the code, but this is done using a regex. |
| // This is a workaround for this until we do a better job at only removing the prefix only when we should. |
| '"' + this.USE + ' ' + this.STRICT + '";\n' + |
| this.filterPrefix() + |
| 'var fn=' + this.generateFunction('fn', 's,l,a,i') + |
| extra + |
| this.watchFns() + |
| 'return fn;'; |
| |
| /* jshint -W054 */ |
| var fn = (new Function('$filter', |
| 'ensureSafeMemberName', |
| 'ensureSafeObject', |
| 'ensureSafeFunction', |
| 'getStringValue', |
| 'ensureSafeAssignContext', |
| 'ifDefined', |
| 'plus', |
| 'text', |
| fnString))( |
| this.$filter, |
| ensureSafeMemberName, |
| ensureSafeObject, |
| ensureSafeFunction, |
| getStringValue, |
| ensureSafeAssignContext, |
| ifDefined, |
| plusFn, |
| expression); |
| /* jshint +W054 */ |
| this.state = this.stage = undefined; |
| fn.literal = isLiteral(ast); |
| fn.constant = isConstant(ast); |
| return fn; |
| }, |
| |
| USE: 'use', |
| |
| STRICT: 'strict', |
| |
| watchFns: function() { |
| var result = []; |
| var fns = this.state.inputs; |
| var self = this; |
| forEach(fns, function(name) { |
| result.push('var ' + name + '=' + self.generateFunction(name, 's')); |
| }); |
| if (fns.length) { |
| result.push('fn.inputs=[' + fns.join(',') + '];'); |
| } |
| return result.join(''); |
| }, |
| |
| generateFunction: function(name, params) { |
| return 'function(' + params + '){' + |
| this.varsPrefix(name) + |
| this.body(name) + |
| '};'; |
| }, |
| |
| filterPrefix: function() { |
| var parts = []; |
| var self = this; |
| forEach(this.state.filters, function(id, filter) { |
| parts.push(id + '=$filter(' + self.escape(filter) + ')'); |
| }); |
| if (parts.length) return 'var ' + parts.join(',') + ';'; |
| return ''; |
| }, |
| |
| varsPrefix: function(section) { |
| return this.state[section].vars.length ? 'var ' + this.state[section].vars.join(',') + ';' : ''; |
| }, |
| |
| body: function(section) { |
| return this.state[section].body.join(''); |
| }, |
| |
| recurse: function(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck) { |
| var left, right, self = this, args, expression; |
| recursionFn = recursionFn || noop; |
| if (!skipWatchIdCheck && isDefined(ast.watchId)) { |
| intoId = intoId || this.nextId(); |
| this.if_('i', |
| this.lazyAssign(intoId, this.computedMember('i', ast.watchId)), |
| this.lazyRecurse(ast, intoId, nameId, recursionFn, create, true) |
| ); |
| return; |
| } |
| switch (ast.type) { |
| case AST.Program: |
| forEach(ast.body, function(expression, pos) { |
| self.recurse(expression.expression, undefined, undefined, function(expr) { right = expr; }); |
| if (pos !== ast.body.length - 1) { |
| self.current().body.push(right, ';'); |
| } else { |
| self.return_(right); |
| } |
| }); |
| break; |
| case AST.Literal: |
| expression = this.escape(ast.value); |
| this.assign(intoId, expression); |
| recursionFn(expression); |
| break; |
| case AST.UnaryExpression: |
| this.recurse(ast.argument, undefined, undefined, function(expr) { right = expr; }); |
| expression = ast.operator + '(' + this.ifDefined(right, 0) + ')'; |
| this.assign(intoId, expression); |
| recursionFn(expression); |
| break; |
| case AST.BinaryExpression: |
| this.recurse(ast.left, undefined, undefined, function(expr) { left = expr; }); |
| this.recurse(ast.right, undefined, undefined, function(expr) { right = expr; }); |
| if (ast.operator === '+') { |
| expression = this.plus(left, right); |
| } else if (ast.operator === '-') { |
| expression = this.ifDefined(left, 0) + ast.operator + this.ifDefined(right, 0); |
| } else { |
| expression = '(' + left + ')' + ast.operator + '(' + right + ')'; |
| } |
| this.assign(intoId, expression); |
| recursionFn(expression); |
| break; |
| case AST.LogicalExpression: |
| intoId = intoId || this.nextId(); |
| self.recurse(ast.left, intoId); |
| self.if_(ast.operator === '&&' ? intoId : self.not(intoId), self.lazyRecurse(ast.right, intoId)); |
| recursionFn(intoId); |
| break; |
| case AST.ConditionalExpression: |
| intoId = intoId || this.nextId(); |
| self.recurse(ast.test, intoId); |
| self.if_(intoId, self.lazyRecurse(ast.alternate, intoId), self.lazyRecurse(ast.consequent, intoId)); |
| recursionFn(intoId); |
| break; |
| case AST.Identifier: |
| intoId = intoId || this.nextId(); |
| if (nameId) { |
| nameId.context = self.stage === 'inputs' ? 's' : this.assign(this.nextId(), this.getHasOwnProperty('l', ast.name) + '?l:s'); |
| nameId.computed = false; |
| nameId.name = ast.name; |
| } |
| ensureSafeMemberName(ast.name); |
| self.if_(self.stage === 'inputs' || self.not(self.getHasOwnProperty('l', ast.name)), |
| function() { |
| self.if_(self.stage === 'inputs' || 's', function() { |
| if (create && create !== 1) { |
| self.if_( |
| self.not(self.nonComputedMember('s', ast.name)), |
| self.lazyAssign(self.nonComputedMember('s', ast.name), '{}')); |
| } |
| self.assign(intoId, self.nonComputedMember('s', ast.name)); |
| }); |
| }, intoId && self.lazyAssign(intoId, self.nonComputedMember('l', ast.name)) |
| ); |
| if (self.state.expensiveChecks || isPossiblyDangerousMemberName(ast.name)) { |
| self.addEnsureSafeObject(intoId); |
| } |
| recursionFn(intoId); |
| break; |
| case AST.MemberExpression: |
| left = nameId && (nameId.context = this.nextId()) || this.nextId(); |
| intoId = intoId || this.nextId(); |
| self.recurse(ast.object, left, undefined, function() { |
| self.if_(self.notNull(left), function() { |
| if (ast.computed) { |
| right = self.nextId(); |
| self.recurse(ast.property, right); |
| self.getStringValue(right); |
| self.addEnsureSafeMemberName(right); |
| if (create && create !== 1) { |
| self.if_(self.not(self.computedMember(left, right)), self.lazyAssign(self.computedMember(left, right), '{}')); |
| } |
| expression = self.ensureSafeObject(self.computedMember(left, right)); |
| self.assign(intoId, expression); |
| if (nameId) { |
| nameId.computed = true; |
| nameId.name = right; |
| } |
| } else { |
| ensureSafeMemberName(ast.property.name); |
| if (create && create !== 1) { |
| self.if_(self.not(self.nonComputedMember(left, ast.property.name)), self.lazyAssign(self.nonComputedMember(left, ast.property.name), '{}')); |
| } |
| expression = self.nonComputedMember(left, ast.property.name); |
| if (self.state.expensiveChecks || isPossiblyDangerousMemberName(ast.property.name)) { |
| expression = self.ensureSafeObject(expression); |
| } |
| self.assign(intoId, expression); |
| if (nameId) { |
| nameId.computed = false; |
| nameId.name = ast.property.name; |
| } |
| } |
| }, function() { |
| self.assign(intoId, 'undefined'); |
| }); |
| recursionFn(intoId); |
| }, !!create); |
| break; |
| case AST.CallExpression: |
| intoId = intoId || this.nextId(); |
| if (ast.filter) { |
| right = self.filter(ast.callee.name); |
| args = []; |
| forEach(ast.arguments, function(expr) { |
| var argument = self.nextId(); |
| self.recurse(expr, argument); |
| args.push(argument); |
| }); |
| expression = right + '(' + args.join(',') + ')'; |
| self.assign(intoId, expression); |
| recursionFn(intoId); |
| } else { |
| right = self.nextId(); |
| left = {}; |
| args = []; |
| self.recurse(ast.callee, right, left, function() { |
| self.if_(self.notNull(right), function() { |
| self.addEnsureSafeFunction(right); |
| forEach(ast.arguments, function(expr) { |
| self.recurse(expr, self.nextId(), undefined, function(argument) { |
| args.push(self.ensureSafeObject(argument)); |
| }); |
| }); |
| if (left.name) { |
| if (!self.state.expensiveChecks) { |
| self.addEnsureSafeObject(left.context); |
| } |
| expression = self.member(left.context, left.name, left.computed) + '(' + args.join(',') + ')'; |
| } else { |
| expression = right + '(' + args.join(',') + ')'; |
| } |
| expression = self.ensureSafeObject(expression); |
| self.assign(intoId, expression); |
| }, function() { |
| self.assign(intoId, 'undefined'); |
| }); |
| recursionFn(intoId); |
| }); |
| } |
| break; |
| case AST.AssignmentExpression: |
| right = this.nextId(); |
| left = {}; |
| if (!isAssignable(ast.left)) { |
| throw $parseMinErr('lval', 'Trying to assing a value to a non l-value'); |
| } |
| this.recurse(ast.left, undefined, left, function() { |
| self.if_(self.notNull(left.context), function() { |
| self.recurse(ast.right, right); |
| self.addEnsureSafeObject(self.member(left.context, left.name, left.computed)); |
| self.addEnsureSafeAssignContext(left.context); |
| expression = self.member(left.context, left.name, left.computed) + ast.operator + right; |
| self.assign(intoId, expression); |
| recursionFn(intoId || expression); |
| }); |
| }, 1); |
| break; |
| case AST.ArrayExpression: |
| args = []; |
| forEach(ast.elements, function(expr) { |
| self.recurse(expr, self.nextId(), undefined, function(argument) { |
| args.push(argument); |
| }); |
| }); |
| expression = '[' + args.join(',') + ']'; |
| this.assign(intoId, expression); |
| recursionFn(expression); |
| break; |
| case AST.ObjectExpression: |
| args = []; |
| forEach(ast.properties, function(property) { |
| self.recurse(property.value, self.nextId(), undefined, function(expr) { |
| args.push(self.escape( |
| property.key.type === AST.Identifier ? property.key.name : |
| ('' + property.key.value)) + |
| ':' + expr); |
| }); |
| }); |
| expression = '{' + args.join(',') + '}'; |
| this.assign(intoId, expression); |
| recursionFn(expression); |
| break; |
| case AST.ThisExpression: |
| this.assign(intoId, 's'); |
| recursionFn('s'); |
| break; |
| case AST.NGValueParameter: |
| this.assign(intoId, 'v'); |
| recursionFn('v'); |
| break; |
| } |
| }, |
| |
| getHasOwnProperty: function(element, property) { |
| var key = element + '.' + property; |
| var own = this.current().own; |
| if (!own.hasOwnProperty(key)) { |
| own[key] = this.nextId(false, element + '&&(' + this.escape(property) + ' in ' + element + ')'); |
| } |
| return own[key]; |
| }, |
| |
| assign: function(id, value) { |
| if (!id) return; |
| this.current().body.push(id, '=', value, ';'); |
| return id; |
| }, |
| |
| filter: function(filterName) { |
| if (!this.state.filters.hasOwnProperty(filterName)) { |
| this.state.filters[filterName] = this.nextId(true); |
| } |
| return this.state.filters[filterName]; |
| }, |
| |
| ifDefined: function(id, defaultValue) { |
| return 'ifDefined(' + id + ',' + this.escape(defaultValue) + ')'; |
| }, |
| |
| plus: function(left, right) { |
| return 'plus(' + left + ',' + right + ')'; |
| }, |
| |
| return_: function(id) { |
| this.current().body.push('return ', id, ';'); |
| }, |
| |
| if_: function(test, alternate, consequent) { |
| if (test === true) { |
| alternate(); |
| } else { |
| var body = this.current().body; |
| body.push('if(', test, '){'); |
| alternate(); |
| body.push('}'); |
| if (consequent) { |
| body.push('else{'); |
| consequent(); |
| body.push('}'); |
| } |
| } |
| }, |
| |
| not: function(expression) { |
| return '!(' + expression + ')'; |
| }, |
| |
| notNull: function(expression) { |
| return expression + '!=null'; |
| }, |
| |
| nonComputedMember: function(left, right) { |
| return left + '.' + right; |
| }, |
| |
| computedMember: function(left, right) { |
| return left + '[' + right + ']'; |
| }, |
| |
| member: function(left, right, computed) { |
| if (computed) return this.computedMember(left, right); |
| return this.nonComputedMember(left, right); |
| }, |
| |
| addEnsureSafeObject: function(item) { |
| this.current().body.push(this.ensureSafeObject(item), ';'); |
| }, |
| |
| addEnsureSafeMemberName: function(item) { |
| this.current().body.push(this.ensureSafeMemberName(item), ';'); |
| }, |
| |
| addEnsureSafeFunction: function(item) { |
| this.current().body.push(this.ensureSafeFunction(item), ';'); |
| }, |
| |
| addEnsureSafeAssignContext: function(item) { |
| this.current().body.push(this.ensureSafeAssignContext(item), ';'); |
| }, |
| |
| ensureSafeObject: function(item) { |
| return 'ensureSafeObject(' + item + ',text)'; |
| }, |
| |
| ensureSafeMemberName: function(item) { |
| return 'ensureSafeMemberName(' + item + ',text)'; |
| }, |
| |
| ensureSafeFunction: function(item) { |
| return 'ensureSafeFunction(' + item + ',text)'; |
| }, |
| |
| getStringValue: function(item) { |
| this.assign(item, 'getStringValue(' + item + ',text)'); |
| }, |
| |
| ensureSafeAssignContext: function(item) { |
| return 'ensureSafeAssignContext(' + item + ',text)'; |
| }, |
| |
| lazyRecurse: function(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck) { |
| var self = this; |
| return function() { |
| self.recurse(ast, intoId, nameId, recursionFn, create, skipWatchIdCheck); |
| }; |
| }, |
| |
| lazyAssign: function(id, value) { |
| var self = this; |
| return function() { |
| self.assign(id, value); |
| }; |
| }, |
| |
| stringEscapeRegex: /[^ a-zA-Z0-9]/g, |
| |
| stringEscapeFn: function(c) { |
| return '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4); |
| }, |
| |
| escape: function(value) { |
| if (isString(value)) return "'" + value.replace(this.stringEscapeRegex, this.stringEscapeFn) + "'"; |
| if (isNumber(value)) return value.toString(); |
| if (value === true) return 'true'; |
| if (value === false) return 'false'; |
| if (value === null) return 'null'; |
| if (typeof value === 'undefined') return 'undefined'; |
| |
| throw $parseMinErr('esc', 'IMPOSSIBLE'); |
| }, |
| |
| nextId: function(skip, init) { |
| var id = 'v' + (this.state.nextId++); |
| if (!skip) { |
| this.current().vars.push(id + (init ? '=' + init : '')); |
| } |
| return id; |
| }, |
| |
| current: function() { |
| return this.state[this.state.computing]; |
| } |
| }; |
| |
| |
| function ASTInterpreter(astBuilder, $filter) { |
| this.astBuilder = astBuilder; |
| this.$filter = $filter; |
| } |
| |
| ASTInterpreter.prototype = { |
| compile: function(expression, expensiveChecks) { |
| var self = this; |
| var ast = this.astBuilder.ast(expression); |
| this.expression = expression; |
| this.expensiveChecks = expensiveChecks; |
| findConstantAndWatchExpressions(ast, self.$filter); |
| var assignable; |
| var assign; |
| if ((assignable = assignableAST(ast))) { |
| assign = this.recurse(assignable); |
| } |
| var toWatch = getInputs(ast.body); |
| var inputs; |
| if (toWatch) { |
| inputs = []; |
| forEach(toWatch, function(watch, key) { |
| var input = self.recurse(watch); |
| watch.input = input; |
| inputs.push(input); |
| watch.watchId = key; |
| }); |
| } |
| var expressions = []; |
| forEach(ast.body, function(expression) { |
| expressions.push(self.recurse(expression.expression)); |
| }); |
| var fn = ast.body.length === 0 ? function() {} : |
| ast.body.length === 1 ? expressions[0] : |
| function(scope, locals) { |
| var lastValue; |
| forEach(expressions, function(exp) { |
| lastValue = exp(scope, locals); |
| }); |
| return lastValue; |
| }; |
| if (assign) { |
| fn.assign = function(scope, value, locals) { |
| return assign(scope, locals, value); |
| }; |
| } |
| if (inputs) { |
| fn.inputs = inputs; |
| } |
| fn.literal = isLiteral(ast); |
| fn.constant = isConstant(ast); |
| return fn; |
| }, |
| |
| recurse: function(ast, context, create) { |
| var left, right, self = this, args, expression; |
| if (ast.input) { |
| return this.inputs(ast.input, ast.watchId); |
| } |
| switch (ast.type) { |
| case AST.Literal: |
| return this.value(ast.value, context); |
| case AST.UnaryExpression: |
| right = this.recurse(ast.argument); |
| return this['unary' + ast.operator](right, context); |
| case AST.BinaryExpression: |
| left = this.recurse(ast.left); |
| right = this.recurse(ast.right); |
| return this['binary' + ast.operator](left, right, context); |
| case AST.LogicalExpression: |
| left = this.recurse(ast.left); |
| right = this.recurse(ast.right); |
| return this['binary' + ast.operator](left, right, context); |
| case AST.ConditionalExpression: |
| return this['ternary?:']( |
| this.recurse(ast.test), |
| this.recurse(ast.alternate), |
| this.recurse(ast.consequent), |
| context |
| ); |
| case AST.Identifier: |
| ensureSafeMemberName(ast.name, self.expression); |
| return self.identifier(ast.name, |
| self.expensiveChecks || isPossiblyDangerousMemberName(ast.name), |
| context, create, self.expression); |
| case AST.MemberExpression: |
| left = this.recurse(ast.object, false, !!create); |
| if (!ast.computed) { |
| ensureSafeMemberName(ast.property.name, self.expression); |
| right = ast.property.name; |
| } |
| if (ast.computed) right = this.recurse(ast.property); |
| return ast.computed ? |
| this.computedMember(left, right, context, create, self.expression) : |
| this.nonComputedMember(left, right, self.expensiveChecks, context, create, self.expression); |
| case AST.CallExpression: |
| args = []; |
| forEach(ast.arguments, function(expr) { |
| args.push(self.recurse(expr)); |
| }); |
| if (ast.filter) right = this.$filter(ast.callee.name); |
| if (!ast.filter) right = this.recurse(ast.callee, true); |
| return ast.filter ? |
| function(scope, locals, assign, inputs) { |
| var values = []; |
| for (var i = 0; i < args.length; ++i) { |
| values.push(args[i](scope, locals, assign, inputs)); |
| } |
| var value = right.apply(undefined, values, inputs); |
| return context ? {context: undefined, name: undefined, value: value} : value; |
| } : |
| function(scope, locals, assign, inputs) { |
| var rhs = right(scope, locals, assign, inputs); |
| var value; |
| if (rhs.value != null) { |
| ensureSafeObject(rhs.context, self.expression); |
| ensureSafeFunction(rhs.value, self.expression); |
| var values = []; |
| for (var i = 0; i < args.length; ++i) { |
| values.push(ensureSafeObject(args[i](scope, locals, assign, inputs), self.expression)); |
| } |
| value = ensureSafeObject(rhs.value.apply(rhs.context, values), self.expression); |
| } |
| return context ? {value: value} : value; |
| }; |
| case AST.AssignmentExpression: |
| left = this.recurse(ast.left, true, 1); |
| right = this.recurse(ast.right); |
| return function(scope, locals, assign, inputs) { |
| var lhs = left(scope, locals, assign, inputs); |
| var rhs = right(scope, locals, assign, inputs); |
| ensureSafeObject(lhs.value, self.expression); |
| ensureSafeAssignContext(lhs.context); |
| lhs.context[lhs.name] = rhs; |
| return context ? {value: rhs} : rhs; |
| }; |
| case AST.ArrayExpression: |
| args = []; |
| forEach(ast.elements, function(expr) { |
| args.push(self.recurse(expr)); |
| }); |
| return function(scope, locals, assign, inputs) { |
| var value = []; |
| for (var i = 0; i < args.length; ++i) { |
| value.push(args[i](scope, locals, assign, inputs)); |
| } |
| return context ? {value: value} : value; |
| }; |
| case AST.ObjectExpression: |
| args = []; |
| forEach(ast.properties, function(property) { |
| args.push({key: property.key.type === AST.Identifier ? |
| property.key.name : |
| ('' + property.key.value), |
| value: self.recurse(property.value) |
| }); |
| }); |
| return function(scope, locals, assign, inputs) { |
| var value = {}; |
| for (var i = 0; i < args.length; ++i) { |
| value[args[i].key] = args[i].value(scope, locals, assign, inputs); |
| } |
| return context ? {value: value} : value; |
| }; |
| case AST.ThisExpression: |
| return function(scope) { |
| return context ? {value: scope} : scope; |
| }; |
| case AST.NGValueParameter: |
| return function(scope, locals, assign, inputs) { |
| return context ? {value: assign} : assign; |
| }; |
| } |
| }, |
| |
| 'unary+': function(argument, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = argument(scope, locals, assign, inputs); |
| if (isDefined(arg)) { |
| arg = +arg; |
| } else { |
| arg = 0; |
| } |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'unary-': function(argument, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = argument(scope, locals, assign, inputs); |
| if (isDefined(arg)) { |
| arg = -arg; |
| } else { |
| arg = 0; |
| } |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'unary!': function(argument, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = !argument(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary+': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var lhs = left(scope, locals, assign, inputs); |
| var rhs = right(scope, locals, assign, inputs); |
| var arg = plusFn(lhs, rhs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary-': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var lhs = left(scope, locals, assign, inputs); |
| var rhs = right(scope, locals, assign, inputs); |
| var arg = (isDefined(lhs) ? lhs : 0) - (isDefined(rhs) ? rhs : 0); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary*': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) * right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary/': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) / right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary%': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) % right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary===': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) === right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary!==': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) !== right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary==': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) == right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary!=': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) != right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary<': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) < right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary>': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) > right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary<=': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) <= right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary>=': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) >= right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary&&': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) && right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'binary||': function(left, right, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = left(scope, locals, assign, inputs) || right(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| 'ternary?:': function(test, alternate, consequent, context) { |
| return function(scope, locals, assign, inputs) { |
| var arg = test(scope, locals, assign, inputs) ? alternate(scope, locals, assign, inputs) : consequent(scope, locals, assign, inputs); |
| return context ? {value: arg} : arg; |
| }; |
| }, |
| value: function(value, context) { |
| return function() { return context ? {context: undefined, name: undefined, value: value} : value; }; |
| }, |
| identifier: function(name, expensiveChecks, context, create, expression) { |
| return function(scope, locals, assign, inputs) { |
| var base = locals && (name in locals) ? locals : scope; |
| if (create && create !== 1 && base && !(base[name])) { |
| base[name] = {}; |
| } |
| var value = base ? base[name] : undefined; |
| if (expensiveChecks) { |
| ensureSafeObject(value, expression); |
| } |
| if (context) { |
| return {context: base, name: name, value: value}; |
| } else { |
| return value; |
| } |
| }; |
| }, |
| computedMember: function(left, right, context, create, expression) { |
| return function(scope, locals, assign, inputs) { |
| var lhs = left(scope, locals, assign, inputs); |
| var rhs; |
| var value; |
| if (lhs != null) { |
| rhs = right(scope, locals, assign, inputs); |
| rhs = getStringValue(rhs); |
| ensureSafeMemberName(rhs, expression); |
| if (create && create !== 1 && lhs && !(lhs[rhs])) { |
| lhs[rhs] = {}; |
| } |
| value = lhs[rhs]; |
| ensureSafeObject(value, expression); |
| } |
| if (context) { |
| return {context: lhs, name: rhs, value: value}; |
| } else { |
| return value; |
| } |
| }; |
| }, |
| nonComputedMember: function(left, right, expensiveChecks, context, create, expression) { |
| return function(scope, locals, assign, inputs) { |
| var lhs = left(scope, locals, assign, inputs); |
| if (create && create !== 1 && lhs && !(lhs[right])) { |
| lhs[right] = {}; |
| } |
| var value = lhs != null ? lhs[right] : undefined; |
| if (expensiveChecks || isPossiblyDangerousMemberName(right)) { |
| ensureSafeObject(value, expression); |
| } |
| if (context) { |
| return {context: lhs, name: right, value: value}; |
| } else { |
| return value; |
| } |
| }; |
| }, |
| inputs: function(input, watchId) { |
| return function(scope, value, locals, inputs) { |
| if (inputs) return inputs[watchId]; |
| return input(scope, value, locals); |
| }; |
| } |
| }; |
| |
| /** |
| * @constructor |
| */ |
| var Parser = function(lexer, $filter, options) { |
| this.lexer = lexer; |
| this.$filter = $filter; |
| this.options = options; |
| this.ast = new AST(this.lexer); |
| this.astCompiler = options.csp ? new ASTInterpreter(this.ast, $filter) : |
| new ASTCompiler(this.ast, $filter); |
| }; |
| |
| Parser.prototype = { |
| constructor: Parser, |
| |
| parse: function(text) { |
| return this.astCompiler.compile(text, this.options.expensiveChecks); |
| } |
| }; |
| |
| var getterFnCacheDefault = createMap(); |
| var getterFnCacheExpensive = createMap(); |
| |
| function isPossiblyDangerousMemberName(name) { |
| return name == 'constructor'; |
| } |
| |
| var objectValueOf = Object.prototype.valueOf; |
| |
| function getValueOf(value) { |
| return isFunction(value.valueOf) ? value.valueOf() : objectValueOf.call(value); |
| } |
| |
| /////////////////////////////////// |
| |
| /** |
| * @ngdoc service |
| * @name $parse |
| * @kind function |
| * |
| * @description |
| * |
| * Converts Angular {@link guide/expression expression} into a function. |
| * |
| * ```js |
| * var getter = $parse('user.name'); |
| * var setter = getter.assign; |
| * var context = {user:{name:'angular'}}; |
| * var locals = {user:{name:'local'}}; |
| * |
| * expect(getter(context)).toEqual('angular'); |
| * setter(context, 'newValue'); |
| * expect(context.user.name).toEqual('newValue'); |
| * expect(getter(context, locals)).toEqual('local'); |
| * ``` |
| * |
| * |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| * |
| * The returned function also has the following properties: |
| * * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript |
| * literal. |
| * * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript |
| * constant literals. |
| * * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be |
| * set to a function to change its value on the given context. |
| * |
| */ |
| |
| |
| /** |
| * @ngdoc provider |
| * @name $parseProvider |
| * |
| * @description |
| * `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse} |
| * service. |
| */ |
| function $ParseProvider() { |
| var cacheDefault = createMap(); |
| var cacheExpensive = createMap(); |
| |
| this.$get = ['$filter', function($filter) { |
| var noUnsafeEval = csp().noUnsafeEval; |
| var $parseOptions = { |
| csp: noUnsafeEval, |
| expensiveChecks: false |
| }, |
| $parseOptionsExpensive = { |
| csp: noUnsafeEval, |
| expensiveChecks: true |
| }; |
| |
| return function $parse(exp, interceptorFn, expensiveChecks) { |
| var parsedExpression, oneTime, cacheKey; |
| |
| switch (typeof exp) { |
| case 'string': |
| exp = exp.trim(); |
| cacheKey = exp; |
| |
| var cache = (expensiveChecks ? cacheExpensive : cacheDefault); |
| parsedExpression = cache[cacheKey]; |
| |
| if (!parsedExpression) { |
| if (exp.charAt(0) === ':' && exp.charAt(1) === ':') { |
| oneTime = true; |
| exp = exp.substring(2); |
| } |
| var parseOptions = expensiveChecks ? $parseOptionsExpensive : $parseOptions; |
| var lexer = new Lexer(parseOptions); |
| var parser = new Parser(lexer, $filter, parseOptions); |
| parsedExpression = parser.parse(exp); |
| if (parsedExpression.constant) { |
| parsedExpression.$$watchDelegate = constantWatchDelegate; |
| } else if (oneTime) { |
| parsedExpression.$$watchDelegate = parsedExpression.literal ? |
| oneTimeLiteralWatchDelegate : oneTimeWatchDelegate; |
| } else if (parsedExpression.inputs) { |
| parsedExpression.$$watchDelegate = inputsWatchDelegate; |
| } |
| cache[cacheKey] = parsedExpression; |
| } |
| return addInterceptor(parsedExpression, interceptorFn); |
| |
| case 'function': |
| return addInterceptor(exp, interceptorFn); |
| |
| default: |
| return noop; |
| } |
| }; |
| |
| function expressionInputDirtyCheck(newValue, oldValueOfValue) { |
| |
| if (newValue == null || oldValueOfValue == null) { // null/undefined |
| return newValue === oldValueOfValue; |
| } |
| |
| if (typeof newValue === 'object') { |
| |
| // attempt to convert the value to a primitive type |
| // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can |
| // be cheaply dirty-checked |
| newValue = getValueOf(newValue); |
| |
| if (typeof newValue === 'object') { |
| // objects/arrays are not supported - deep-watching them would be too expensive |
| return false; |
| } |
| |
| // fall-through to the primitive equality check |
| } |
| |
| //Primitive or NaN |
| return newValue === oldValueOfValue || (newValue !== newValue && oldValueOfValue !== oldValueOfValue); |
| } |
| |
| function inputsWatchDelegate(scope, listener, objectEquality, parsedExpression, prettyPrintExpression) { |
| var inputExpressions = parsedExpression.inputs; |
| var lastResult; |
| |
| if (inputExpressions.length === 1) { |
| var oldInputValueOf = expressionInputDirtyCheck; // init to something unique so that equals check fails |
| inputExpressions = inputExpressions[0]; |
| return scope.$watch(function expressionInputWatch(scope) { |
| var newInputValue = inputExpressions(scope); |
| if (!expressionInputDirtyCheck(newInputValue, oldInputValueOf)) { |
| lastResult = parsedExpression(scope, undefined, undefined, [newInputValue]); |
| oldInputValueOf = newInputValue && getValueOf(newInputValue); |
| } |
| return lastResult; |
| }, listener, objectEquality, prettyPrintExpression); |
| } |
| |
| var oldInputValueOfValues = []; |
| var oldInputValues = []; |
| for (var i = 0, ii = inputExpressions.length; i < ii; i++) { |
| oldInputValueOfValues[i] = expressionInputDirtyCheck; // init to something unique so that equals check fails |
| oldInputValues[i] = null; |
| } |
| |
| return scope.$watch(function expressionInputsWatch(scope) { |
| var changed = false; |
| |
| for (var i = 0, ii = inputExpressions.length; i < ii; i++) { |
| var newInputValue = inputExpressions[i](scope); |
| if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) { |
| oldInputValues[i] = newInputValue; |
| oldInputValueOfValues[i] = newInputValue && getValueOf(newInputValue); |
| } |
| } |
| |
| if (changed) { |
| lastResult = parsedExpression(scope, undefined, undefined, oldInputValues); |
| } |
| |
| return lastResult; |
| }, listener, objectEquality, prettyPrintExpression); |
| } |
| |
| function oneTimeWatchDelegate(scope, listener, objectEquality, parsedExpression) { |
| var unwatch, lastValue; |
| return unwatch = scope.$watch(function oneTimeWatch(scope) { |
| return parsedExpression(scope); |
| }, function oneTimeListener(value, old, scope) { |
| lastValue = value; |
| if (isFunction(listener)) { |
| listener.apply(this, arguments); |
| } |
| if (isDefined(value)) { |
| scope.$$postDigest(function() { |
| if (isDefined(lastValue)) { |
| unwatch(); |
| } |
| }); |
| } |
| }, objectEquality); |
| } |
| |
| function oneTimeLiteralWatchDelegate(scope, listener, objectEquality, parsedExpression) { |
| var unwatch, lastValue; |
| return unwatch = scope.$watch(function oneTimeWatch(scope) { |
| return parsedExpression(scope); |
| }, function oneTimeListener(value, old, scope) { |
| lastValue = value; |
| if (isFunction(listener)) { |
| listener.call(this, value, old, scope); |
| } |
| if (isAllDefined(value)) { |
| scope.$$postDigest(function() { |
| if (isAllDefined(lastValue)) unwatch(); |
| }); |
| } |
| }, objectEquality); |
| |
| function isAllDefined(value) { |
| var allDefined = true; |
| forEach(value, function(val) { |
| if (!isDefined(val)) allDefined = false; |
| }); |
| return allDefined; |
| } |
| } |
| |
| function constantWatchDelegate(scope, listener, objectEquality, parsedExpression) { |
| var unwatch; |
| return unwatch = scope.$watch(function constantWatch(scope) { |
| return parsedExpression(scope); |
| }, function constantListener(value, old, scope) { |
| if (isFunction(listener)) { |
| listener.apply(this, arguments); |
| } |
| unwatch(); |
| }, objectEquality); |
| } |
| |
| function addInterceptor(parsedExpression, interceptorFn) { |
| if (!interceptorFn) return parsedExpression; |
| var watchDelegate = parsedExpression.$$watchDelegate; |
| |
| var regularWatch = |
| watchDelegate !== oneTimeLiteralWatchDelegate && |
| watchDelegate !== oneTimeWatchDelegate; |
| |
| var fn = regularWatch ? function regularInterceptedExpression(scope, locals, assign, inputs) { |
| var value = parsedExpression(scope, locals, assign, inputs); |
| return interceptorFn(value, scope, locals); |
| } : function oneTimeInterceptedExpression(scope, locals, assign, inputs) { |
| var value = parsedExpression(scope, locals, assign, inputs); |
| var result = interceptorFn(value, scope, locals); |
| // we only return the interceptor's result if the |
| // initial value is defined (for bind-once) |
| return isDefined(value) ? result : value; |
| }; |
| |
| // Propagate $$watchDelegates other then inputsWatchDelegate |
| if (parsedExpression.$$watchDelegate && |
| parsedExpression.$$watchDelegate !== inputsWatchDelegate) { |
| fn.$$watchDelegate = parsedExpression.$$watchDelegate; |
| } else if (!interceptorFn.$stateful) { |
| // If there is an interceptor, but no watchDelegate then treat the interceptor like |
| // we treat filters - it is assumed to be a pure function unless flagged with $stateful |
| fn.$$watchDelegate = inputsWatchDelegate; |
| fn.inputs = parsedExpression.inputs ? parsedExpression.inputs : [parsedExpression]; |
| } |
| |
| return fn; |
| } |
| }]; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $q |
| * @requires $rootScope |
| * |
| * @description |
| * A service that helps you run functions asynchronously, and use their return values (or exceptions) |
| * when they are done processing. |
| * |
| * This is an implementation of promises/deferred objects inspired by |
| * [Kris Kowal's Q](https://github.com/kriskowal/q). |
| * |
| * $q can be used in two fashions --- one which is more similar to Kris Kowal's Q or jQuery's Deferred |
| * implementations, and the other which resembles ES6 promises to some degree. |
| * |
| * # $q constructor |
| * |
| * The streamlined ES6 style promise is essentially just using $q as a constructor which takes a `resolver` |
| * function as the first argument. This is similar to the native Promise implementation from ES6 Harmony, |
| * see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). |
| * |
| * While the constructor-style use is supported, not all of the supporting methods from ES6 Harmony promises are |
| * available yet. |
| * |
| * It can be used like so: |
| * |
| * ```js |
| * // for the purpose of this example let's assume that variables `$q` and `okToGreet` |
| * // are available in the current lexical scope (they could have been injected or passed in). |
| * |
| * function asyncGreet(name) { |
| * // perform some asynchronous operation, resolve or reject the promise when appropriate. |
| * return $q(function(resolve, reject) { |
| * setTimeout(function() { |
| * if (okToGreet(name)) { |
| * resolve('Hello, ' + name + '!'); |
| * } else { |
| * reject('Greeting ' + name + ' is not allowed.'); |
| * } |
| * }, 1000); |
| * }); |
| * } |
| * |
| * var promise = asyncGreet('Robin Hood'); |
| * promise.then(function(greeting) { |
| * alert('Success: ' + greeting); |
| * }, function(reason) { |
| * alert('Failed: ' + reason); |
| * }); |
| * ``` |
| * |
| * Note: progress/notify callbacks are not currently supported via the ES6-style interface. |
| * |
| * However, the more traditional CommonJS-style usage is still available, and documented below. |
| * |
| * [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an |
| * interface for interacting with an object that represents the result of an action that is |
| * performed asynchronously, and may or may not be finished at any given point in time. |
| * |
| * From the perspective of dealing with error handling, deferred and promise APIs are to |
| * asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming. |
| * |
| * ```js |
| * // for the purpose of this example let's assume that variables `$q` and `okToGreet` |
| * // are available in the current lexical scope (they could have been injected or passed in). |
| * |
| * function asyncGreet(name) { |
| * var deferred = $q.defer(); |
| * |
| * setTimeout(function() { |
| * deferred.notify('About to greet ' + name + '.'); |
| * |
| * if (okToGreet(name)) { |
| * deferred.resolve('Hello, ' + name + '!'); |
| * } else { |
| * deferred.reject('Greeting ' + name + ' is not allowed.'); |
| * } |
| * }, 1000); |
| * |
| * return deferred.promise; |
| * } |
| * |
| * var promise = asyncGreet('Robin Hood'); |
| * promise.then(function(greeting) { |
| * alert('Success: ' + greeting); |
| * }, function(reason) { |
| * alert('Failed: ' + reason); |
| * }, function(update) { |
| * alert('Got notification: ' + update); |
| * }); |
| * ``` |
| * |
| * At first it might not be obvious why this extra complexity is worth the trouble. The payoff |
| * comes in the way of guarantees that promise and deferred APIs make, see |
| * https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md. |
| * |
| * Additionally the promise api allows for composition that is very hard to do with the |
| * traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach. |
| * For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the |
| * section on serial or parallel joining of promises. |
| * |
| * # The Deferred API |
| * |
| * A new instance of deferred is constructed by calling `$q.defer()`. |
| * |
| * The purpose of the deferred object is to expose the associated Promise instance as well as APIs |
| * that can be used for signaling the successful or unsuccessful completion, as well as the status |
| * of the task. |
| * |
| * **Methods** |
| * |
| * - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection |
| * constructed via `$q.reject`, the promise will be rejected instead. |
| * - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to |
| * resolving it with a rejection constructed via `$q.reject`. |
| * - `notify(value)` - provides updates on the status of the promise's execution. This may be called |
| * multiple times before the promise is either resolved or rejected. |
| * |
| * **Properties** |
| * |
| * - promise – `{Promise}` – promise object associated with this deferred. |
| * |
| * |
| * # The Promise API |
| * |
| * A new promise instance is created when a deferred instance is created and can be retrieved by |
| * calling `deferred.promise`. |
| * |
| * The purpose of the promise object is to allow for interested parties to get access to the result |
| * of the deferred task when it completes. |
| * |
| * **Methods** |
| * |
| * - `then(successCallback, errorCallback, notifyCallback)` – regardless of when the promise was or |
| * will be resolved or rejected, `then` calls one of the success or error callbacks asynchronously |
| * as soon as the result is available. The callbacks are called with a single argument: the result |
| * or rejection reason. Additionally, the notify callback may be called zero or more times to |
| * provide a progress indication, before the promise is resolved or rejected. |
| * |
| * This method *returns a new promise* which is resolved or rejected via the return value of the |
| * `successCallback`, `errorCallback` (unless that value is a promise, in which case it is resolved |
| * with the value which is resolved in that promise using |
| * [promise chaining](http://www.html5rocks.com/en/tutorials/es6/promises/#toc-promises-queues)). |
| * It also notifies via the return value of the `notifyCallback` method. The promise cannot be |
| * resolved or rejected from the notifyCallback method. |
| * |
| * - `catch(errorCallback)` – shorthand for `promise.then(null, errorCallback)` |
| * |
| * - `finally(callback, notifyCallback)` – allows you to observe either the fulfillment or rejection of a promise, |
| * but to do so without modifying the final value. This is useful to release resources or do some |
| * clean-up that needs to be done whether the promise was rejected or resolved. See the [full |
| * specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for |
| * more information. |
| * |
| * # Chaining promises |
| * |
| * Because calling the `then` method of a promise returns a new derived promise, it is easily |
| * possible to create a chain of promises: |
| * |
| * ```js |
| * promiseB = promiseA.then(function(result) { |
| * return result + 1; |
| * }); |
| * |
| * // promiseB will be resolved immediately after promiseA is resolved and its value |
| * // will be the result of promiseA incremented by 1 |
| * ``` |
| * |
| * It is possible to create chains of any length and since a promise can be resolved with another |
| * promise (which will defer its resolution further), it is possible to pause/defer resolution of |
| * the promises at any point in the chain. This makes it possible to implement powerful APIs like |
| * $http's response interceptors. |
| * |
| * |
| * # Differences between Kris Kowal's Q and $q |
| * |
| * There are two main differences: |
| * |
| * - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation |
| * mechanism in angular, which means faster propagation of resolution or rejection into your |
| * models and avoiding unnecessary browser repaints, which would result in flickering UI. |
| * - Q has many more features than $q, but that comes at a cost of bytes. $q is tiny, but contains |
| * all the important functionality needed for common async tasks. |
| * |
| * # Testing |
| * |
| * ```js |
| * it('should simulate promise', inject(function($q, $rootScope) { |
| * var deferred = $q.defer(); |
| * var promise = deferred.promise; |
| * var resolvedValue; |
| * |
| * promise.then(function(value) { resolvedValue = value; }); |
| * expect(resolvedValue).toBeUndefined(); |
| * |
| * // Simulate resolving of promise |
| * deferred.resolve(123); |
| * // Note that the 'then' function does not get called synchronously. |
| * // This is because we want the promise API to always be async, whether or not |
| * // it got called synchronously or asynchronously. |
| * expect(resolvedValue).toBeUndefined(); |
| * |
| * // Propagate promise resolution to 'then' functions using $apply(). |
| * $rootScope.$apply(); |
| * expect(resolvedValue).toEqual(123); |
| * })); |
| * ``` |
| * |
| * @param {function(function, function)} resolver Function which is responsible for resolving or |
| * rejecting the newly created promise. The first parameter is a function which resolves the |
| * promise, the second parameter is a function which rejects the promise. |
| * |
| * @returns {Promise} The newly created promise. |
| */ |
| function $QProvider() { |
| |
| this.$get = ['$rootScope', '$exceptionHandler', function($rootScope, $exceptionHandler) { |
| return qFactory(function(callback) { |
| $rootScope.$evalAsync(callback); |
| }, $exceptionHandler); |
| }]; |
| } |
| |
| function $$QProvider() { |
| this.$get = ['$browser', '$exceptionHandler', function($browser, $exceptionHandler) { |
| return qFactory(function(callback) { |
| $browser.defer(callback); |
| }, $exceptionHandler); |
| }]; |
| } |
| |
| /** |
| * Constructs a promise manager. |
| * |
| * @param {function(function)} nextTick Function for executing functions in the next turn. |
| * @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for |
| * debugging purposes. |
| * @returns {object} Promise manager. |
| */ |
| function qFactory(nextTick, exceptionHandler) { |
| var $qMinErr = minErr('$q', TypeError); |
| function callOnce(self, resolveFn, rejectFn) { |
| var called = false; |
| function wrap(fn) { |
| return function(value) { |
| if (called) return; |
| called = true; |
| fn.call(self, value); |
| }; |
| } |
| |
| return [wrap(resolveFn), wrap(rejectFn)]; |
| } |
| |
| /** |
| * @ngdoc method |
| * @name ng.$q#defer |
| * @kind function |
| * |
| * @description |
| * Creates a `Deferred` object which represents a task which will finish in the future. |
| * |
| * @returns {Deferred} Returns a new instance of deferred. |
| */ |
| var defer = function() { |
| return new Deferred(); |
| }; |
| |
| function Promise() { |
| this.$$state = { status: 0 }; |
| } |
| |
| extend(Promise.prototype, { |
| then: function(onFulfilled, onRejected, progressBack) { |
| if (isUndefined(onFulfilled) && isUndefined(onRejected) && isUndefined(progressBack)) { |
| return this; |
| } |
| var result = new Deferred(); |
| |
| this.$$state.pending = this.$$state.pending || []; |
| this.$$state.pending.push([result, onFulfilled, onRejected, progressBack]); |
| if (this.$$state.status > 0) scheduleProcessQueue(this.$$state); |
| |
| return result.promise; |
| }, |
| |
| "catch": function(callback) { |
| return this.then(null, callback); |
| }, |
| |
| "finally": function(callback, progressBack) { |
| return this.then(function(value) { |
| return handleCallback(value, true, callback); |
| }, function(error) { |
| return handleCallback(error, false, callback); |
| }, progressBack); |
| } |
| }); |
| |
| //Faster, more basic than angular.bind http://jsperf.com/angular-bind-vs-custom-vs-native |
| function simpleBind(context, fn) { |
| return function(value) { |
| fn.call(context, value); |
| }; |
| } |
| |
| function processQueue(state) { |
| var fn, deferred, pending; |
| |
| pending = state.pending; |
| state.processScheduled = false; |
| state.pending = undefined; |
| for (var i = 0, ii = pending.length; i < ii; ++i) { |
| deferred = pending[i][0]; |
| fn = pending[i][state.status]; |
| try { |
| if (isFunction(fn)) { |
| deferred.resolve(fn(state.value)); |
| } else if (state.status === 1) { |
| deferred.resolve(state.value); |
| } else { |
| deferred.reject(state.value); |
| } |
| } catch (e) { |
| deferred.reject(e); |
| exceptionHandler(e); |
| } |
| } |
| } |
| |
| function scheduleProcessQueue(state) { |
| if (state.processScheduled || !state.pending) return; |
| state.processScheduled = true; |
| nextTick(function() { processQueue(state); }); |
| } |
| |
| function Deferred() { |
| this.promise = new Promise(); |
| //Necessary to support unbound execution :/ |
| this.resolve = simpleBind(this, this.resolve); |
| this.reject = simpleBind(this, this.reject); |
| this.notify = simpleBind(this, this.notify); |
| } |
| |
| extend(Deferred.prototype, { |
| resolve: function(val) { |
| if (this.promise.$$state.status) return; |
| if (val === this.promise) { |
| this.$$reject($qMinErr( |
| 'qcycle', |
| "Expected promise to be resolved with value other than itself '{0}'", |
| val)); |
| } else { |
| this.$$resolve(val); |
| } |
| |
| }, |
| |
| $$resolve: function(val) { |
| var then, fns; |
| |
| fns = callOnce(this, this.$$resolve, this.$$reject); |
| try { |
| if ((isObject(val) || isFunction(val))) then = val && val.then; |
| if (isFunction(then)) { |
| this.promise.$$state.status = -1; |
| then.call(val, fns[0], fns[1], this.notify); |
| } else { |
| this.promise.$$state.value = val; |
| this.promise.$$state.status = 1; |
| scheduleProcessQueue(this.promise.$$state); |
| } |
| } catch (e) { |
| fns[1](e); |
| exceptionHandler(e); |
| } |
| }, |
| |
| reject: function(reason) { |
| if (this.promise.$$state.status) return; |
| this.$$reject(reason); |
| }, |
| |
| $$reject: function(reason) { |
| this.promise.$$state.value = reason; |
| this.promise.$$state.status = 2; |
| scheduleProcessQueue(this.promise.$$state); |
| }, |
| |
| notify: function(progress) { |
| var callbacks = this.promise.$$state.pending; |
| |
| if ((this.promise.$$state.status <= 0) && callbacks && callbacks.length) { |
| nextTick(function() { |
| var callback, result; |
| for (var i = 0, ii = callbacks.length; i < ii; i++) { |
| result = callbacks[i][0]; |
| callback = callbacks[i][3]; |
| try { |
| result.notify(isFunction(callback) ? callback(progress) : progress); |
| } catch (e) { |
| exceptionHandler(e); |
| } |
| } |
| }); |
| } |
| } |
| }); |
| |
| /** |
| * @ngdoc method |
| * @name $q#reject |
| * @kind function |
| * |
| * @description |
| * Creates a promise that is resolved as rejected with the specified `reason`. This api should be |
| * used to forward rejection in a chain of promises. If you are dealing with the last promise in |
| * a promise chain, you don't need to worry about it. |
| * |
| * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of |
| * `reject` as the `throw` keyword in JavaScript. This also means that if you "catch" an error via |
| * a promise error callback and you want to forward the error to the promise derived from the |
| * current promise, you have to "rethrow" the error by returning a rejection constructed via |
| * `reject`. |
| * |
| * ```js |
| * promiseB = promiseA.then(function(result) { |
| * // success: do something and resolve promiseB |
| * // with the old or a new result |
| * return result; |
| * }, function(reason) { |
| * // error: handle the error if possible and |
| * // resolve promiseB with newPromiseOrValue, |
| * // otherwise forward the rejection to promiseB |
| * if (canHandle(reason)) { |
| * // handle the error and recover |
| * return newPromiseOrValue; |
| * } |
| * return $q.reject(reason); |
| * }); |
| * ``` |
| * |
| * @param {*} reason Constant, message, exception or an object representing the rejection reason. |
| * @returns {Promise} Returns a promise that was already resolved as rejected with the `reason`. |
| */ |
| var reject = function(reason) { |
| var result = new Deferred(); |
| result.reject(reason); |
| return result.promise; |
| }; |
| |
| var makePromise = function makePromise(value, resolved) { |
| var result = new Deferred(); |
| if (resolved) { |
| result.resolve(value); |
| } else { |
| result.reject(value); |
| } |
| return result.promise; |
| }; |
| |
| var handleCallback = function handleCallback(value, isResolved, callback) { |
| var callbackOutput = null; |
| try { |
| if (isFunction(callback)) callbackOutput = callback(); |
| } catch (e) { |
| return makePromise(e, false); |
| } |
| if (isPromiseLike(callbackOutput)) { |
| return callbackOutput.then(function() { |
| return makePromise(value, isResolved); |
| }, function(error) { |
| return makePromise(error, false); |
| }); |
| } else { |
| return makePromise(value, isResolved); |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $q#when |
| * @kind function |
| * |
| * @description |
| * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. |
| * This is useful when you are dealing with an object that might or might not be a promise, or if |
| * the promise comes from a source that can't be trusted. |
| * |
| * @param {*} value Value or a promise |
| * @param {Function=} successCallback |
| * @param {Function=} errorCallback |
| * @param {Function=} progressCallback |
| * @returns {Promise} Returns a promise of the passed value or promise |
| */ |
| |
| |
| var when = function(value, callback, errback, progressBack) { |
| var result = new Deferred(); |
| result.resolve(value); |
| return result.promise.then(callback, errback, progressBack); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $q#resolve |
| * @kind function |
| * |
| * @description |
| * Alias of {@link ng.$q#when when} to maintain naming consistency with ES6. |
| * |
| * @param {*} value Value or a promise |
| * @param {Function=} successCallback |
| * @param {Function=} errorCallback |
| * @param {Function=} progressCallback |
| * @returns {Promise} Returns a promise of the passed value or promise |
| */ |
| var resolve = when; |
| |
| /** |
| * @ngdoc method |
| * @name $q#all |
| * @kind function |
| * |
| * @description |
| * Combines multiple promises into a single promise that is resolved when all of the input |
| * promises are resolved. |
| * |
| * @param {Array.<Promise>|Object.<Promise>} promises An array or hash of promises. |
| * @returns {Promise} Returns a single promise that will be resolved with an array/hash of values, |
| * each value corresponding to the promise at the same index/key in the `promises` array/hash. |
| * If any of the promises is resolved with a rejection, this resulting promise will be rejected |
| * with the same rejection value. |
| */ |
| |
| function all(promises) { |
| var deferred = new Deferred(), |
| counter = 0, |
| results = isArray(promises) ? [] : {}; |
| |
| forEach(promises, function(promise, key) { |
| counter++; |
| when(promise).then(function(value) { |
| if (results.hasOwnProperty(key)) return; |
| results[key] = value; |
| if (!(--counter)) deferred.resolve(results); |
| }, function(reason) { |
| if (results.hasOwnProperty(key)) return; |
| deferred.reject(reason); |
| }); |
| }); |
| |
| if (counter === 0) { |
| deferred.resolve(results); |
| } |
| |
| return deferred.promise; |
| } |
| |
| var $Q = function Q(resolver) { |
| if (!isFunction(resolver)) { |
| throw $qMinErr('norslvr', "Expected resolverFn, got '{0}'", resolver); |
| } |
| |
| if (!(this instanceof Q)) { |
| // More useful when $Q is the Promise itself. |
| return new Q(resolver); |
| } |
| |
| var deferred = new Deferred(); |
| |
| function resolveFn(value) { |
| deferred.resolve(value); |
| } |
| |
| function rejectFn(reason) { |
| deferred.reject(reason); |
| } |
| |
| resolver(resolveFn, rejectFn); |
| |
| return deferred.promise; |
| }; |
| |
| $Q.defer = defer; |
| $Q.reject = reject; |
| $Q.when = when; |
| $Q.resolve = resolve; |
| $Q.all = all; |
| |
| return $Q; |
| } |
| |
| function $$RAFProvider() { //rAF |
| this.$get = ['$window', '$timeout', function($window, $timeout) { |
| var requestAnimationFrame = $window.requestAnimationFrame || |
| $window.webkitRequestAnimationFrame; |
| |
| var cancelAnimationFrame = $window.cancelAnimationFrame || |
| $window.webkitCancelAnimationFrame || |
| $window.webkitCancelRequestAnimationFrame; |
| |
| var rafSupported = !!requestAnimationFrame; |
| var raf = rafSupported |
| ? function(fn) { |
| var id = requestAnimationFrame(fn); |
| return function() { |
| cancelAnimationFrame(id); |
| }; |
| } |
| : function(fn) { |
| var timer = $timeout(fn, 16.66, false); // 1000 / 60 = 16.666 |
| return function() { |
| $timeout.cancel(timer); |
| }; |
| }; |
| |
| raf.supported = rafSupported; |
| |
| return raf; |
| }]; |
| } |
| |
| /** |
| * DESIGN NOTES |
| * |
| * The design decisions behind the scope are heavily favored for speed and memory consumption. |
| * |
| * The typical use of scope is to watch the expressions, which most of the time return the same |
| * value as last time so we optimize the operation. |
| * |
| * Closures construction is expensive in terms of speed as well as memory: |
| * - No closures, instead use prototypical inheritance for API |
| * - Internal state needs to be stored on scope directly, which means that private state is |
| * exposed as $$____ properties |
| * |
| * Loop operations are optimized by using while(count--) { ... } |
| * - this means that in order to keep the same order of execution as addition we have to add |
| * items to the array at the beginning (unshift) instead of at the end (push) |
| * |
| * Child scopes are created and removed often |
| * - Using an array would be slow since inserts in middle are expensive so we use linked list |
| * |
| * There are few watches then a lot of observers. This is why you don't want the observer to be |
| * implemented in the same way as watch. Watch requires return of initialization function which |
| * are expensive to construct. |
| */ |
| |
| |
| /** |
| * @ngdoc provider |
| * @name $rootScopeProvider |
| * @description |
| * |
| * Provider for the $rootScope service. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $rootScopeProvider#digestTtl |
| * @description |
| * |
| * Sets the number of `$digest` iterations the scope should attempt to execute before giving up and |
| * assuming that the model is unstable. |
| * |
| * The current default is 10 iterations. |
| * |
| * In complex applications it's possible that the dependencies between `$watch`s will result in |
| * several digest iterations. However if an application needs more than the default 10 digest |
| * iterations for its model to stabilize then you should investigate what is causing the model to |
| * continuously change during the digest. |
| * |
| * Increasing the TTL could have performance implications, so you should not change it without |
| * proper justification. |
| * |
| * @param {number} limit The number of digest iterations. |
| */ |
| |
| |
| /** |
| * @ngdoc service |
| * @name $rootScope |
| * @description |
| * |
| * Every application has a single root {@link ng.$rootScope.Scope scope}. |
| * All other scopes are descendant scopes of the root scope. Scopes provide separation |
| * between the model and the view, via a mechanism for watching the model for changes. |
| * They also provide an event emission/broadcast and subscription facility. See the |
| * {@link guide/scope developer guide on scopes}. |
| */ |
| function $RootScopeProvider() { |
| var TTL = 10; |
| var $rootScopeMinErr = minErr('$rootScope'); |
| var lastDirtyWatch = null; |
| var applyAsyncId = null; |
| |
| this.digestTtl = function(value) { |
| if (arguments.length) { |
| TTL = value; |
| } |
| return TTL; |
| }; |
| |
| function createChildScopeClass(parent) { |
| function ChildScope() { |
| this.$$watchers = this.$$nextSibling = |
| this.$$childHead = this.$$childTail = null; |
| this.$$listeners = {}; |
| this.$$listenerCount = {}; |
| this.$$watchersCount = 0; |
| this.$id = nextUid(); |
| this.$$ChildScope = null; |
| } |
| ChildScope.prototype = parent; |
| return ChildScope; |
| } |
| |
| this.$get = ['$injector', '$exceptionHandler', '$parse', '$browser', |
| function($injector, $exceptionHandler, $parse, $browser) { |
| |
| function destroyChildScope($event) { |
| $event.currentScope.$$destroyed = true; |
| } |
| |
| /** |
| * @ngdoc type |
| * @name $rootScope.Scope |
| * |
| * @description |
| * A root scope can be retrieved using the {@link ng.$rootScope $rootScope} key from the |
| * {@link auto.$injector $injector}. Child scopes are created using the |
| * {@link ng.$rootScope.Scope#$new $new()} method. (Most scopes are created automatically when |
| * compiled HTML template is executed.) See also the {@link guide/scope Scopes guide} for |
| * an in-depth introduction and usage examples. |
| * |
| * |
| * # Inheritance |
| * A scope can inherit from a parent scope, as in this example: |
| * ```js |
| var parent = $rootScope; |
| var child = parent.$new(); |
| |
| parent.salutation = "Hello"; |
| expect(child.salutation).toEqual('Hello'); |
| |
| child.salutation = "Welcome"; |
| expect(child.salutation).toEqual('Welcome'); |
| expect(parent.salutation).toEqual('Hello'); |
| * ``` |
| * |
| * When interacting with `Scope` in tests, additional helper methods are available on the |
| * instances of `Scope` type. See {@link ngMock.$rootScope.Scope ngMock Scope} for additional |
| * details. |
| * |
| * |
| * @param {Object.<string, function()>=} providers Map of service factory which need to be |
| * provided for the current scope. Defaults to {@link ng}. |
| * @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should |
| * append/override services provided by `providers`. This is handy |
| * when unit-testing and having the need to override a default |
| * service. |
| * @returns {Object} Newly created scope. |
| * |
| */ |
| function Scope() { |
| this.$id = nextUid(); |
| this.$$phase = this.$parent = this.$$watchers = |
| this.$$nextSibling = this.$$prevSibling = |
| this.$$childHead = this.$$childTail = null; |
| this.$root = this; |
| this.$$destroyed = false; |
| this.$$listeners = {}; |
| this.$$listenerCount = {}; |
| this.$$watchersCount = 0; |
| this.$$isolateBindings = null; |
| } |
| |
| /** |
| * @ngdoc property |
| * @name $rootScope.Scope#$id |
| * |
| * @description |
| * Unique scope ID (monotonically increasing) useful for debugging. |
| */ |
| |
| /** |
| * @ngdoc property |
| * @name $rootScope.Scope#$parent |
| * |
| * @description |
| * Reference to the parent scope. |
| */ |
| |
| /** |
| * @ngdoc property |
| * @name $rootScope.Scope#$root |
| * |
| * @description |
| * Reference to the root scope. |
| */ |
| |
| Scope.prototype = { |
| constructor: Scope, |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$new |
| * @kind function |
| * |
| * @description |
| * Creates a new child {@link ng.$rootScope.Scope scope}. |
| * |
| * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} event. |
| * The scope can be removed from the scope hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}. |
| * |
| * {@link ng.$rootScope.Scope#$destroy $destroy()} must be called on a scope when it is |
| * desired for the scope and its child scopes to be permanently detached from the parent and |
| * thus stop participating in model change detection and listener notification by invoking. |
| * |
| * @param {boolean} isolate If true, then the scope does not prototypically inherit from the |
| * parent scope. The scope is isolated, as it can not see parent scope properties. |
| * When creating widgets, it is useful for the widget to not accidentally read parent |
| * state. |
| * |
| * @param {Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent` |
| * of the newly created scope. Defaults to `this` scope if not provided. |
| * This is used when creating a transclude scope to correctly place it |
| * in the scope hierarchy while maintaining the correct prototypical |
| * inheritance. |
| * |
| * @returns {Object} The newly created child scope. |
| * |
| */ |
| $new: function(isolate, parent) { |
| var child; |
| |
| parent = parent || this; |
| |
| if (isolate) { |
| child = new Scope(); |
| child.$root = this.$root; |
| } else { |
| // Only create a child scope class if somebody asks for one, |
| // but cache it to allow the VM to optimize lookups. |
| if (!this.$$ChildScope) { |
| this.$$ChildScope = createChildScopeClass(this); |
| } |
| child = new this.$$ChildScope(); |
| } |
| child.$parent = parent; |
| child.$$prevSibling = parent.$$childTail; |
| if (parent.$$childHead) { |
| parent.$$childTail.$$nextSibling = child; |
| parent.$$childTail = child; |
| } else { |
| parent.$$childHead = parent.$$childTail = child; |
| } |
| |
| // When the new scope is not isolated or we inherit from `this`, and |
| // the parent scope is destroyed, the property `$$destroyed` is inherited |
| // prototypically. In all other cases, this property needs to be set |
| // when the parent scope is destroyed. |
| // The listener needs to be added after the parent is set |
| if (isolate || parent != this) child.$on('$destroy', destroyChildScope); |
| |
| return child; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$watch |
| * @kind function |
| * |
| * @description |
| * Registers a `listener` callback to be executed whenever the `watchExpression` changes. |
| * |
| * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#$digest |
| * $digest()} and should return the value that will be watched. (`watchExpression` should not change |
| * its value when executed multiple times with the same input because it may be executed multiple |
| * times by {@link ng.$rootScope.Scope#$digest $digest()}. That is, `watchExpression` should be |
| * [idempotent](http://en.wikipedia.org/wiki/Idempotence). |
| * - The `listener` is called only when the value from the current `watchExpression` and the |
| * previous call to `watchExpression` are not equal (with the exception of the initial run, |
| * see below). Inequality is determined according to reference inequality, |
| * [strict comparison](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) |
| * via the `!==` Javascript operator, unless `objectEquality == true` |
| * (see next point) |
| * - When `objectEquality == true`, inequality of the `watchExpression` is determined |
| * according to the {@link angular.equals} function. To save the value of the object for |
| * later comparison, the {@link angular.copy} function is used. This therefore means that |
| * watching complex objects will have adverse memory and performance implications. |
| * - The watch `listener` may change the model, which may trigger other `listener`s to fire. |
| * This is achieved by rerunning the watchers until no changes are detected. The rerun |
| * iteration limit is 10 to prevent an infinite loop deadlock. |
| * |
| * |
| * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called, |
| * you can register a `watchExpression` function with no `listener`. (Be prepared for |
| * multiple calls to your `watchExpression` because it will execute multiple times in a |
| * single {@link ng.$rootScope.Scope#$digest $digest} cycle if a change is detected.) |
| * |
| * After a watcher is registered with the scope, the `listener` fn is called asynchronously |
| * (via {@link ng.$rootScope.Scope#$evalAsync $evalAsync}) to initialize the |
| * watcher. In rare cases, this is undesirable because the listener is called when the result |
| * of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you |
| * can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the |
| * listener was called due to initialization. |
| * |
| * |
| * |
| * # Example |
| * ```js |
| // let's assume that scope was dependency injected as the $rootScope |
| var scope = $rootScope; |
| scope.name = 'misko'; |
| scope.counter = 0; |
| |
| expect(scope.counter).toEqual(0); |
| scope.$watch('name', function(newValue, oldValue) { |
| scope.counter = scope.counter + 1; |
| }); |
| expect(scope.counter).toEqual(0); |
| |
| scope.$digest(); |
| // the listener is always called during the first $digest loop after it was registered |
| expect(scope.counter).toEqual(1); |
| |
| scope.$digest(); |
| // but now it will not be called unless the value changes |
| expect(scope.counter).toEqual(1); |
| |
| scope.name = 'adam'; |
| scope.$digest(); |
| expect(scope.counter).toEqual(2); |
| |
| |
| |
| // Using a function as a watchExpression |
| var food; |
| scope.foodCounter = 0; |
| expect(scope.foodCounter).toEqual(0); |
| scope.$watch( |
| // This function returns the value being watched. It is called for each turn of the $digest loop |
| function() { return food; }, |
| // This is the change listener, called when the value returned from the above function changes |
| function(newValue, oldValue) { |
| if ( newValue !== oldValue ) { |
| // Only increment the counter if the value changed |
| scope.foodCounter = scope.foodCounter + 1; |
| } |
| } |
| ); |
| // No digest has been run so the counter will be zero |
| expect(scope.foodCounter).toEqual(0); |
| |
| // Run the digest but since food has not changed count will still be zero |
| scope.$digest(); |
| expect(scope.foodCounter).toEqual(0); |
| |
| // Update food and run digest. Now the counter will increment |
| food = 'cheeseburger'; |
| scope.$digest(); |
| expect(scope.foodCounter).toEqual(1); |
| |
| * ``` |
| * |
| * |
| * |
| * @param {(function()|string)} watchExpression Expression that is evaluated on each |
| * {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers |
| * a call to the `listener`. |
| * |
| * - `string`: Evaluated as {@link guide/expression expression} |
| * - `function(scope)`: called with current `scope` as a parameter. |
| * @param {function(newVal, oldVal, scope)} listener Callback called whenever the value |
| * of `watchExpression` changes. |
| * |
| * - `newVal` contains the current value of the `watchExpression` |
| * - `oldVal` contains the previous value of the `watchExpression` |
| * - `scope` refers to the current scope |
| * @param {boolean=} objectEquality Compare for object equality using {@link angular.equals} instead of |
| * comparing for reference equality. |
| * @returns {function()} Returns a deregistration function for this listener. |
| */ |
| $watch: function(watchExp, listener, objectEquality, prettyPrintExpression) { |
| var get = $parse(watchExp); |
| |
| if (get.$$watchDelegate) { |
| return get.$$watchDelegate(this, listener, objectEquality, get, watchExp); |
| } |
| var scope = this, |
| array = scope.$$watchers, |
| watcher = { |
| fn: listener, |
| last: initWatchVal, |
| get: get, |
| exp: prettyPrintExpression || watchExp, |
| eq: !!objectEquality |
| }; |
| |
| lastDirtyWatch = null; |
| |
| if (!isFunction(listener)) { |
| watcher.fn = noop; |
| } |
| |
| if (!array) { |
| array = scope.$$watchers = []; |
| } |
| // we use unshift since we use a while loop in $digest for speed. |
| // the while loop reads in reverse order. |
| array.unshift(watcher); |
| incrementWatchersCount(this, 1); |
| |
| return function deregisterWatch() { |
| if (arrayRemove(array, watcher) >= 0) { |
| incrementWatchersCount(scope, -1); |
| } |
| lastDirtyWatch = null; |
| }; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$watchGroup |
| * @kind function |
| * |
| * @description |
| * A variant of {@link ng.$rootScope.Scope#$watch $watch()} where it watches an array of `watchExpressions`. |
| * If any one expression in the collection changes the `listener` is executed. |
| * |
| * - The items in the `watchExpressions` array are observed via standard $watch operation and are examined on every |
| * call to $digest() to see if any items changes. |
| * - The `listener` is called whenever any expression in the `watchExpressions` array changes. |
| * |
| * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually |
| * watched using {@link ng.$rootScope.Scope#$watch $watch()} |
| * |
| * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any |
| * expression in `watchExpressions` changes |
| * The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching |
| * those of `watchExpression` |
| * and the `oldValues` array contains the previous values of the `watchExpressions`, with the indexes matching |
| * those of `watchExpression` |
| * The `scope` refers to the current scope. |
| * @returns {function()} Returns a de-registration function for all listeners. |
| */ |
| $watchGroup: function(watchExpressions, listener) { |
| var oldValues = new Array(watchExpressions.length); |
| var newValues = new Array(watchExpressions.length); |
| var deregisterFns = []; |
| var self = this; |
| var changeReactionScheduled = false; |
| var firstRun = true; |
| |
| if (!watchExpressions.length) { |
| // No expressions means we call the listener ASAP |
| var shouldCall = true; |
| self.$evalAsync(function() { |
| if (shouldCall) listener(newValues, newValues, self); |
| }); |
| return function deregisterWatchGroup() { |
| shouldCall = false; |
| }; |
| } |
| |
| if (watchExpressions.length === 1) { |
| // Special case size of one |
| return this.$watch(watchExpressions[0], function watchGroupAction(value, oldValue, scope) { |
| newValues[0] = value; |
| oldValues[0] = oldValue; |
| listener(newValues, (value === oldValue) ? newValues : oldValues, scope); |
| }); |
| } |
| |
| forEach(watchExpressions, function(expr, i) { |
| var unwatchFn = self.$watch(expr, function watchGroupSubAction(value, oldValue) { |
| newValues[i] = value; |
| oldValues[i] = oldValue; |
| if (!changeReactionScheduled) { |
| changeReactionScheduled = true; |
| self.$evalAsync(watchGroupAction); |
| } |
| }); |
| deregisterFns.push(unwatchFn); |
| }); |
| |
| function watchGroupAction() { |
| changeReactionScheduled = false; |
| |
| if (firstRun) { |
| firstRun = false; |
| listener(newValues, newValues, self); |
| } else { |
| listener(newValues, oldValues, self); |
| } |
| } |
| |
| return function deregisterWatchGroup() { |
| while (deregisterFns.length) { |
| deregisterFns.shift()(); |
| } |
| }; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$watchCollection |
| * @kind function |
| * |
| * @description |
| * Shallow watches the properties of an object and fires whenever any of the properties change |
| * (for arrays, this implies watching the array items; for object maps, this implies watching |
| * the properties). If a change is detected, the `listener` callback is fired. |
| * |
| * - The `obj` collection is observed via standard $watch operation and is examined on every |
| * call to $digest() to see if any items have been added, removed, or moved. |
| * - The `listener` is called whenever anything within the `obj` has changed. Examples include |
| * adding, removing, and moving items belonging to an object or array. |
| * |
| * |
| * # Example |
| * ```js |
| $scope.names = ['igor', 'matias', 'misko', 'james']; |
| $scope.dataCount = 4; |
| |
| $scope.$watchCollection('names', function(newNames, oldNames) { |
| $scope.dataCount = newNames.length; |
| }); |
| |
| expect($scope.dataCount).toEqual(4); |
| $scope.$digest(); |
| |
| //still at 4 ... no changes |
| expect($scope.dataCount).toEqual(4); |
| |
| $scope.names.pop(); |
| $scope.$digest(); |
| |
| //now there's been a change |
| expect($scope.dataCount).toEqual(3); |
| * ``` |
| * |
| * |
| * @param {string|function(scope)} obj Evaluated as {@link guide/expression expression}. The |
| * expression value should evaluate to an object or an array which is observed on each |
| * {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the |
| * collection will trigger a call to the `listener`. |
| * |
| * @param {function(newCollection, oldCollection, scope)} listener a callback function called |
| * when a change is detected. |
| * - The `newCollection` object is the newly modified data obtained from the `obj` expression |
| * - The `oldCollection` object is a copy of the former collection data. |
| * Due to performance considerations, the`oldCollection` value is computed only if the |
| * `listener` function declares two or more arguments. |
| * - The `scope` argument refers to the current scope. |
| * |
| * @returns {function()} Returns a de-registration function for this listener. When the |
| * de-registration function is executed, the internal watch operation is terminated. |
| */ |
| $watchCollection: function(obj, listener) { |
| $watchCollectionInterceptor.$stateful = true; |
| |
| var self = this; |
| // the current value, updated on each dirty-check run |
| var newValue; |
| // a shallow copy of the newValue from the last dirty-check run, |
| // updated to match newValue during dirty-check run |
| var oldValue; |
| // a shallow copy of the newValue from when the last change happened |
| var veryOldValue; |
| // only track veryOldValue if the listener is asking for it |
| var trackVeryOldValue = (listener.length > 1); |
| var changeDetected = 0; |
| var changeDetector = $parse(obj, $watchCollectionInterceptor); |
| var internalArray = []; |
| var internalObject = {}; |
| var initRun = true; |
| var oldLength = 0; |
| |
| function $watchCollectionInterceptor(_value) { |
| newValue = _value; |
| var newLength, key, bothNaN, newItem, oldItem; |
| |
| // If the new value is undefined, then return undefined as the watch may be a one-time watch |
| if (isUndefined(newValue)) return; |
| |
| if (!isObject(newValue)) { // if primitive |
| if (oldValue !== newValue) { |
| oldValue = newValue; |
| changeDetected++; |
| } |
| } else if (isArrayLike(newValue)) { |
| if (oldValue !== internalArray) { |
| // we are transitioning from something which was not an array into array. |
| oldValue = internalArray; |
| oldLength = oldValue.length = 0; |
| changeDetected++; |
| } |
| |
| newLength = newValue.length; |
| |
| if (oldLength !== newLength) { |
| // if lengths do not match we need to trigger change notification |
| changeDetected++; |
| oldValue.length = oldLength = newLength; |
| } |
| // copy the items to oldValue and look for changes. |
| for (var i = 0; i < newLength; i++) { |
| oldItem = oldValue[i]; |
| newItem = newValue[i]; |
| |
| bothNaN = (oldItem !== oldItem) && (newItem !== newItem); |
| if (!bothNaN && (oldItem !== newItem)) { |
| changeDetected++; |
| oldValue[i] = newItem; |
| } |
| } |
| } else { |
| if (oldValue !== internalObject) { |
| // we are transitioning from something which was not an object into object. |
| oldValue = internalObject = {}; |
| oldLength = 0; |
| changeDetected++; |
| } |
| // copy the items to oldValue and look for changes. |
| newLength = 0; |
| for (key in newValue) { |
| if (hasOwnProperty.call(newValue, key)) { |
| newLength++; |
| newItem = newValue[key]; |
| oldItem = oldValue[key]; |
| |
| if (key in oldValue) { |
| bothNaN = (oldItem !== oldItem) && (newItem !== newItem); |
| if (!bothNaN && (oldItem !== newItem)) { |
| changeDetected++; |
| oldValue[key] = newItem; |
| } |
| } else { |
| oldLength++; |
| oldValue[key] = newItem; |
| changeDetected++; |
| } |
| } |
| } |
| if (oldLength > newLength) { |
| // we used to have more keys, need to find them and destroy them. |
| changeDetected++; |
| for (key in oldValue) { |
| if (!hasOwnProperty.call(newValue, key)) { |
| oldLength--; |
| delete oldValue[key]; |
| } |
| } |
| } |
| } |
| return changeDetected; |
| } |
| |
| function $watchCollectionAction() { |
| if (initRun) { |
| initRun = false; |
| listener(newValue, newValue, self); |
| } else { |
| listener(newValue, veryOldValue, self); |
| } |
| |
| // make a copy for the next time a collection is changed |
| if (trackVeryOldValue) { |
| if (!isObject(newValue)) { |
| //primitive |
| veryOldValue = newValue; |
| } else if (isArrayLike(newValue)) { |
| veryOldValue = new Array(newValue.length); |
| for (var i = 0; i < newValue.length; i++) { |
| veryOldValue[i] = newValue[i]; |
| } |
| } else { // if object |
| veryOldValue = {}; |
| for (var key in newValue) { |
| if (hasOwnProperty.call(newValue, key)) { |
| veryOldValue[key] = newValue[key]; |
| } |
| } |
| } |
| } |
| } |
| |
| return this.$watch(changeDetector, $watchCollectionAction); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$digest |
| * @kind function |
| * |
| * @description |
| * Processes all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and |
| * its children. Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change |
| * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#$watch watchers} |
| * until no more listeners are firing. This means that it is possible to get into an infinite |
| * loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of |
| * iterations exceeds 10. |
| * |
| * Usually, you don't call `$digest()` directly in |
| * {@link ng.directive:ngController controllers} or in |
| * {@link ng.$compileProvider#directive directives}. |
| * Instead, you should call {@link ng.$rootScope.Scope#$apply $apply()} (typically from within |
| * a {@link ng.$compileProvider#directive directive}), which will force a `$digest()`. |
| * |
| * If you want to be notified whenever `$digest()` is called, |
| * you can register a `watchExpression` function with |
| * {@link ng.$rootScope.Scope#$watch $watch()} with no `listener`. |
| * |
| * In unit tests, you may need to call `$digest()` to simulate the scope life cycle. |
| * |
| * # Example |
| * ```js |
| var scope = ...; |
| scope.name = 'misko'; |
| scope.counter = 0; |
| |
| expect(scope.counter).toEqual(0); |
| scope.$watch('name', function(newValue, oldValue) { |
| scope.counter = scope.counter + 1; |
| }); |
| expect(scope.counter).toEqual(0); |
| |
| scope.$digest(); |
| // the listener is always called during the first $digest loop after it was registered |
| expect(scope.counter).toEqual(1); |
| |
| scope.$digest(); |
| // but now it will not be called unless the value changes |
| expect(scope.counter).toEqual(1); |
| |
| scope.name = 'adam'; |
| scope.$digest(); |
| expect(scope.counter).toEqual(2); |
| * ``` |
| * |
| */ |
| $digest: function() { |
| var watch, value, last, |
| watchers, |
| length, |
| dirty, ttl = TTL, |
| next, current, target = this, |
| watchLog = [], |
| logIdx, logMsg, asyncTask; |
| |
| beginPhase('$digest'); |
| // Check for changes to browser url that happened in sync before the call to $digest |
| $browser.$$checkUrlChange(); |
| |
| if (this === $rootScope && applyAsyncId !== null) { |
| // If this is the root scope, and $applyAsync has scheduled a deferred $apply(), then |
| // cancel the scheduled $apply and flush the queue of expressions to be evaluated. |
| $browser.defer.cancel(applyAsyncId); |
| flushApplyAsync(); |
| } |
| |
| lastDirtyWatch = null; |
| |
| do { // "while dirty" loop |
| dirty = false; |
| current = target; |
| |
| while (asyncQueue.length) { |
| try { |
| asyncTask = asyncQueue.shift(); |
| asyncTask.scope.$eval(asyncTask.expression, asyncTask.locals); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| lastDirtyWatch = null; |
| } |
| |
| traverseScopesLoop: |
| do { // "traverse the scopes" loop |
| if ((watchers = current.$$watchers)) { |
| // process our watches |
| length = watchers.length; |
| while (length--) { |
| try { |
| watch = watchers[length]; |
| // Most common watches are on primitives, in which case we can short |
| // circuit it with === operator, only when === fails do we use .equals |
| if (watch) { |
| if ((value = watch.get(current)) !== (last = watch.last) && |
| !(watch.eq |
| ? equals(value, last) |
| : (typeof value === 'number' && typeof last === 'number' |
| && isNaN(value) && isNaN(last)))) { |
| dirty = true; |
| lastDirtyWatch = watch; |
| watch.last = watch.eq ? copy(value, null) : value; |
| watch.fn(value, ((last === initWatchVal) ? value : last), current); |
| if (ttl < 5) { |
| logIdx = 4 - ttl; |
| if (!watchLog[logIdx]) watchLog[logIdx] = []; |
| watchLog[logIdx].push({ |
| msg: isFunction(watch.exp) ? 'fn: ' + (watch.exp.name || watch.exp.toString()) : watch.exp, |
| newVal: value, |
| oldVal: last |
| }); |
| } |
| } else if (watch === lastDirtyWatch) { |
| // If the most recently dirty watcher is now clean, short circuit since the remaining watchers |
| // have already been tested. |
| dirty = false; |
| break traverseScopesLoop; |
| } |
| } |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| } |
| } |
| |
| // Insanity Warning: scope depth-first traversal |
| // yes, this code is a bit crazy, but it works and we have tests to prove it! |
| // this piece should be kept in sync with the traversal in $broadcast |
| if (!(next = ((current.$$watchersCount && current.$$childHead) || |
| (current !== target && current.$$nextSibling)))) { |
| while (current !== target && !(next = current.$$nextSibling)) { |
| current = current.$parent; |
| } |
| } |
| } while ((current = next)); |
| |
| // `break traverseScopesLoop;` takes us to here |
| |
| if ((dirty || asyncQueue.length) && !(ttl--)) { |
| clearPhase(); |
| throw $rootScopeMinErr('infdig', |
| '{0} $digest() iterations reached. Aborting!\n' + |
| 'Watchers fired in the last 5 iterations: {1}', |
| TTL, watchLog); |
| } |
| |
| } while (dirty || asyncQueue.length); |
| |
| clearPhase(); |
| |
| while (postDigestQueue.length) { |
| try { |
| postDigestQueue.shift()(); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| } |
| }, |
| |
| |
| /** |
| * @ngdoc event |
| * @name $rootScope.Scope#$destroy |
| * @eventType broadcast on scope being destroyed |
| * |
| * @description |
| * Broadcasted when a scope and its children are being destroyed. |
| * |
| * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to |
| * clean up DOM bindings before an element is removed from the DOM. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$destroy |
| * @kind function |
| * |
| * @description |
| * Removes the current scope (and all of its children) from the parent scope. Removal implies |
| * that calls to {@link ng.$rootScope.Scope#$digest $digest()} will no longer |
| * propagate to the current scope and its children. Removal also implies that the current |
| * scope is eligible for garbage collection. |
| * |
| * The `$destroy()` is usually used by directives such as |
| * {@link ng.directive:ngRepeat ngRepeat} for managing the |
| * unrolling of the loop. |
| * |
| * Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope. |
| * Application code can register a `$destroy` event handler that will give it a chance to |
| * perform any necessary cleanup. |
| * |
| * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to |
| * clean up DOM bindings before an element is removed from the DOM. |
| */ |
| $destroy: function() { |
| // We can't destroy a scope that has been already destroyed. |
| if (this.$$destroyed) return; |
| var parent = this.$parent; |
| |
| this.$broadcast('$destroy'); |
| this.$$destroyed = true; |
| |
| if (this === $rootScope) { |
| //Remove handlers attached to window when $rootScope is removed |
| $browser.$$applicationDestroyed(); |
| } |
| |
| incrementWatchersCount(this, -this.$$watchersCount); |
| for (var eventName in this.$$listenerCount) { |
| decrementListenerCount(this, this.$$listenerCount[eventName], eventName); |
| } |
| |
| // sever all the references to parent scopes (after this cleanup, the current scope should |
| // not be retained by any of our references and should be eligible for garbage collection) |
| if (parent && parent.$$childHead == this) parent.$$childHead = this.$$nextSibling; |
| if (parent && parent.$$childTail == this) parent.$$childTail = this.$$prevSibling; |
| if (this.$$prevSibling) this.$$prevSibling.$$nextSibling = this.$$nextSibling; |
| if (this.$$nextSibling) this.$$nextSibling.$$prevSibling = this.$$prevSibling; |
| |
| // Disable listeners, watchers and apply/digest methods |
| this.$destroy = this.$digest = this.$apply = this.$evalAsync = this.$applyAsync = noop; |
| this.$on = this.$watch = this.$watchGroup = function() { return noop; }; |
| this.$$listeners = {}; |
| |
| // All of the code below is bogus code that works around V8's memory leak via optimized code |
| // and inline caches. |
| // |
| // see: |
| // - https://code.google.com/p/v8/issues/detail?id=2073#c26 |
| // - https://github.com/angular/angular.js/issues/6794#issuecomment-38648909 |
| // - https://github.com/angular/angular.js/issues/1313#issuecomment-10378451 |
| |
| this.$parent = this.$$nextSibling = this.$$prevSibling = this.$$childHead = |
| this.$$childTail = this.$root = this.$$watchers = null; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$eval |
| * @kind function |
| * |
| * @description |
| * Executes the `expression` on the current scope and returns the result. Any exceptions in |
| * the expression are propagated (uncaught). This is useful when evaluating Angular |
| * expressions. |
| * |
| * # Example |
| * ```js |
| var scope = ng.$rootScope.Scope(); |
| scope.a = 1; |
| scope.b = 2; |
| |
| expect(scope.$eval('a+b')).toEqual(3); |
| expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3); |
| * ``` |
| * |
| * @param {(string|function())=} expression An angular expression to be executed. |
| * |
| * - `string`: execute using the rules as defined in {@link guide/expression expression}. |
| * - `function(scope)`: execute the function with the current `scope` parameter. |
| * |
| * @param {(object)=} locals Local variables object, useful for overriding values in scope. |
| * @returns {*} The result of evaluating the expression. |
| */ |
| $eval: function(expr, locals) { |
| return $parse(expr)(this, locals); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$evalAsync |
| * @kind function |
| * |
| * @description |
| * Executes the expression on the current scope at a later point in time. |
| * |
| * The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only |
| * that: |
| * |
| * - it will execute after the function that scheduled the evaluation (preferably before DOM |
| * rendering). |
| * - at least one {@link ng.$rootScope.Scope#$digest $digest cycle} will be performed after |
| * `expression` execution. |
| * |
| * Any exceptions from the execution of the expression are forwarded to the |
| * {@link ng.$exceptionHandler $exceptionHandler} service. |
| * |
| * __Note:__ if this function is called outside of a `$digest` cycle, a new `$digest` cycle |
| * will be scheduled. However, it is encouraged to always call code that changes the model |
| * from within an `$apply` call. That includes code evaluated via `$evalAsync`. |
| * |
| * @param {(string|function())=} expression An angular expression to be executed. |
| * |
| * - `string`: execute using the rules as defined in {@link guide/expression expression}. |
| * - `function(scope)`: execute the function with the current `scope` parameter. |
| * |
| * @param {(object)=} locals Local variables object, useful for overriding values in scope. |
| */ |
| $evalAsync: function(expr, locals) { |
| // if we are outside of an $digest loop and this is the first time we are scheduling async |
| // task also schedule async auto-flush |
| if (!$rootScope.$$phase && !asyncQueue.length) { |
| $browser.defer(function() { |
| if (asyncQueue.length) { |
| $rootScope.$digest(); |
| } |
| }); |
| } |
| |
| asyncQueue.push({scope: this, expression: expr, locals: locals}); |
| }, |
| |
| $$postDigest: function(fn) { |
| postDigestQueue.push(fn); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$apply |
| * @kind function |
| * |
| * @description |
| * `$apply()` is used to execute an expression in angular from outside of the angular |
| * framework. (For example from browser DOM events, setTimeout, XHR or third party libraries). |
| * Because we are calling into the angular framework we need to perform proper scope life |
| * cycle of {@link ng.$exceptionHandler exception handling}, |
| * {@link ng.$rootScope.Scope#$digest executing watches}. |
| * |
| * ## Life cycle |
| * |
| * # Pseudo-Code of `$apply()` |
| * ```js |
| function $apply(expr) { |
| try { |
| return $eval(expr); |
| } catch (e) { |
| $exceptionHandler(e); |
| } finally { |
| $root.$digest(); |
| } |
| } |
| * ``` |
| * |
| * |
| * Scope's `$apply()` method transitions through the following stages: |
| * |
| * 1. The {@link guide/expression expression} is executed using the |
| * {@link ng.$rootScope.Scope#$eval $eval()} method. |
| * 2. Any exceptions from the execution of the expression are forwarded to the |
| * {@link ng.$exceptionHandler $exceptionHandler} service. |
| * 3. The {@link ng.$rootScope.Scope#$watch watch} listeners are fired immediately after the |
| * expression was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method. |
| * |
| * |
| * @param {(string|function())=} exp An angular expression to be executed. |
| * |
| * - `string`: execute using the rules as defined in {@link guide/expression expression}. |
| * - `function(scope)`: execute the function with current `scope` parameter. |
| * |
| * @returns {*} The result of evaluating the expression. |
| */ |
| $apply: function(expr) { |
| try { |
| beginPhase('$apply'); |
| try { |
| return this.$eval(expr); |
| } finally { |
| clearPhase(); |
| } |
| } catch (e) { |
| $exceptionHandler(e); |
| } finally { |
| try { |
| $rootScope.$digest(); |
| } catch (e) { |
| $exceptionHandler(e); |
| throw e; |
| } |
| } |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$applyAsync |
| * @kind function |
| * |
| * @description |
| * Schedule the invocation of $apply to occur at a later time. The actual time difference |
| * varies across browsers, but is typically around ~10 milliseconds. |
| * |
| * This can be used to queue up multiple expressions which need to be evaluated in the same |
| * digest. |
| * |
| * @param {(string|function())=} exp An angular expression to be executed. |
| * |
| * - `string`: execute using the rules as defined in {@link guide/expression expression}. |
| * - `function(scope)`: execute the function with current `scope` parameter. |
| */ |
| $applyAsync: function(expr) { |
| var scope = this; |
| expr && applyAsyncQueue.push($applyAsyncExpression); |
| scheduleApplyAsync(); |
| |
| function $applyAsyncExpression() { |
| scope.$eval(expr); |
| } |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$on |
| * @kind function |
| * |
| * @description |
| * Listens on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for |
| * discussion of event life cycle. |
| * |
| * The event listener function format is: `function(event, args...)`. The `event` object |
| * passed into the listener has the following attributes: |
| * |
| * - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or |
| * `$broadcast`-ed. |
| * - `currentScope` - `{Scope}`: the scope that is currently handling the event. Once the |
| * event propagates through the scope hierarchy, this property is set to null. |
| * - `name` - `{string}`: name of the event. |
| * - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel |
| * further event propagation (available only for events that were `$emit`-ed). |
| * - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag |
| * to true. |
| * - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called. |
| * |
| * @param {string} name Event name to listen on. |
| * @param {function(event, ...args)} listener Function to call when the event is emitted. |
| * @returns {function()} Returns a deregistration function for this listener. |
| */ |
| $on: function(name, listener) { |
| var namedListeners = this.$$listeners[name]; |
| if (!namedListeners) { |
| this.$$listeners[name] = namedListeners = []; |
| } |
| namedListeners.push(listener); |
| |
| var current = this; |
| do { |
| if (!current.$$listenerCount[name]) { |
| current.$$listenerCount[name] = 0; |
| } |
| current.$$listenerCount[name]++; |
| } while ((current = current.$parent)); |
| |
| var self = this; |
| return function() { |
| var indexOfListener = namedListeners.indexOf(listener); |
| if (indexOfListener !== -1) { |
| namedListeners[indexOfListener] = null; |
| decrementListenerCount(self, 1, name); |
| } |
| }; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$emit |
| * @kind function |
| * |
| * @description |
| * Dispatches an event `name` upwards through the scope hierarchy notifying the |
| * registered {@link ng.$rootScope.Scope#$on} listeners. |
| * |
| * The event life cycle starts at the scope on which `$emit` was called. All |
| * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get |
| * notified. Afterwards, the event traverses upwards toward the root scope and calls all |
| * registered listeners along the way. The event will stop propagating if one of the listeners |
| * cancels it. |
| * |
| * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed |
| * onto the {@link ng.$exceptionHandler $exceptionHandler} service. |
| * |
| * @param {string} name Event name to emit. |
| * @param {...*} args Optional one or more arguments which will be passed onto the event listeners. |
| * @return {Object} Event object (see {@link ng.$rootScope.Scope#$on}). |
| */ |
| $emit: function(name, args) { |
| var empty = [], |
| namedListeners, |
| scope = this, |
| stopPropagation = false, |
| event = { |
| name: name, |
| targetScope: scope, |
| stopPropagation: function() {stopPropagation = true;}, |
| preventDefault: function() { |
| event.defaultPrevented = true; |
| }, |
| defaultPrevented: false |
| }, |
| listenerArgs = concat([event], arguments, 1), |
| i, length; |
| |
| do { |
| namedListeners = scope.$$listeners[name] || empty; |
| event.currentScope = scope; |
| for (i = 0, length = namedListeners.length; i < length; i++) { |
| |
| // if listeners were deregistered, defragment the array |
| if (!namedListeners[i]) { |
| namedListeners.splice(i, 1); |
| i--; |
| length--; |
| continue; |
| } |
| try { |
| //allow all listeners attached to the current scope to run |
| namedListeners[i].apply(null, listenerArgs); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| } |
| //if any listener on the current scope stops propagation, prevent bubbling |
| if (stopPropagation) { |
| event.currentScope = null; |
| return event; |
| } |
| //traverse upwards |
| scope = scope.$parent; |
| } while (scope); |
| |
| event.currentScope = null; |
| |
| return event; |
| }, |
| |
| |
| /** |
| * @ngdoc method |
| * @name $rootScope.Scope#$broadcast |
| * @kind function |
| * |
| * @description |
| * Dispatches an event `name` downwards to all child scopes (and their children) notifying the |
| * registered {@link ng.$rootScope.Scope#$on} listeners. |
| * |
| * The event life cycle starts at the scope on which `$broadcast` was called. All |
| * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get |
| * notified. Afterwards, the event propagates to all direct and indirect scopes of the current |
| * scope and calls all registered listeners along the way. The event cannot be canceled. |
| * |
| * Any exception emitted from the {@link ng.$rootScope.Scope#$on listeners} will be passed |
| * onto the {@link ng.$exceptionHandler $exceptionHandler} service. |
| * |
| * @param {string} name Event name to broadcast. |
| * @param {...*} args Optional one or more arguments which will be passed onto the event listeners. |
| * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on} |
| */ |
| $broadcast: function(name, args) { |
| var target = this, |
| current = target, |
| next = target, |
| event = { |
| name: name, |
| targetScope: target, |
| preventDefault: function() { |
| event.defaultPrevented = true; |
| }, |
| defaultPrevented: false |
| }; |
| |
| if (!target.$$listenerCount[name]) return event; |
| |
| var listenerArgs = concat([event], arguments, 1), |
| listeners, i, length; |
| |
| //down while you can, then up and next sibling or up and next sibling until back at root |
| while ((current = next)) { |
| event.currentScope = current; |
| listeners = current.$$listeners[name] || []; |
| for (i = 0, length = listeners.length; i < length; i++) { |
| // if listeners were deregistered, defragment the array |
| if (!listeners[i]) { |
| listeners.splice(i, 1); |
| i--; |
| length--; |
| continue; |
| } |
| |
| try { |
| listeners[i].apply(null, listenerArgs); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| } |
| |
| // Insanity Warning: scope depth-first traversal |
| // yes, this code is a bit crazy, but it works and we have tests to prove it! |
| // this piece should be kept in sync with the traversal in $digest |
| // (though it differs due to having the extra check for $$listenerCount) |
| if (!(next = ((current.$$listenerCount[name] && current.$$childHead) || |
| (current !== target && current.$$nextSibling)))) { |
| while (current !== target && !(next = current.$$nextSibling)) { |
| current = current.$parent; |
| } |
| } |
| } |
| |
| event.currentScope = null; |
| return event; |
| } |
| }; |
| |
| var $rootScope = new Scope(); |
| |
| //The internal queues. Expose them on the $rootScope for debugging/testing purposes. |
| var asyncQueue = $rootScope.$$asyncQueue = []; |
| var postDigestQueue = $rootScope.$$postDigestQueue = []; |
| var applyAsyncQueue = $rootScope.$$applyAsyncQueue = []; |
| |
| return $rootScope; |
| |
| |
| function beginPhase(phase) { |
| if ($rootScope.$$phase) { |
| throw $rootScopeMinErr('inprog', '{0} already in progress', $rootScope.$$phase); |
| } |
| |
| $rootScope.$$phase = phase; |
| } |
| |
| function clearPhase() { |
| $rootScope.$$phase = null; |
| } |
| |
| function incrementWatchersCount(current, count) { |
| do { |
| current.$$watchersCount += count; |
| } while ((current = current.$parent)); |
| } |
| |
| function decrementListenerCount(current, count, name) { |
| do { |
| current.$$listenerCount[name] -= count; |
| |
| if (current.$$listenerCount[name] === 0) { |
| delete current.$$listenerCount[name]; |
| } |
| } while ((current = current.$parent)); |
| } |
| |
| /** |
| * function used as an initial value for watchers. |
| * because it's unique we can easily tell it apart from other values |
| */ |
| function initWatchVal() {} |
| |
| function flushApplyAsync() { |
| while (applyAsyncQueue.length) { |
| try { |
| applyAsyncQueue.shift()(); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| } |
| applyAsyncId = null; |
| } |
| |
| function scheduleApplyAsync() { |
| if (applyAsyncId === null) { |
| applyAsyncId = $browser.defer(function() { |
| $rootScope.$apply(flushApplyAsync); |
| }); |
| } |
| } |
| }]; |
| } |
| |
| /** |
| * @description |
| * Private service to sanitize uris for links and images. Used by $compile and $sanitize. |
| */ |
| function $$SanitizeUriProvider() { |
| var aHrefSanitizationWhitelist = /^\s*(https?|ftp|mailto|tel|file):/, |
| imgSrcSanitizationWhitelist = /^\s*((https?|ftp|file|blob):|data:image\/)/; |
| |
| /** |
| * @description |
| * Retrieves or overrides the default regular expression that is used for whitelisting of safe |
| * urls during a[href] sanitization. |
| * |
| * The sanitization is a security measure aimed at prevent XSS attacks via html links. |
| * |
| * Any url about to be assigned to a[href] via data-binding is first normalized and turned into |
| * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist` |
| * regular expression. If a match is found, the original url is written into the dom. Otherwise, |
| * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM. |
| * |
| * @param {RegExp=} regexp New regexp to whitelist urls with. |
| * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for |
| * chaining otherwise. |
| */ |
| this.aHrefSanitizationWhitelist = function(regexp) { |
| if (isDefined(regexp)) { |
| aHrefSanitizationWhitelist = regexp; |
| return this; |
| } |
| return aHrefSanitizationWhitelist; |
| }; |
| |
| |
| /** |
| * @description |
| * Retrieves or overrides the default regular expression that is used for whitelisting of safe |
| * urls during img[src] sanitization. |
| * |
| * The sanitization is a security measure aimed at prevent XSS attacks via html links. |
| * |
| * Any url about to be assigned to img[src] via data-binding is first normalized and turned into |
| * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist` |
| * regular expression. If a match is found, the original url is written into the dom. Otherwise, |
| * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM. |
| * |
| * @param {RegExp=} regexp New regexp to whitelist urls with. |
| * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for |
| * chaining otherwise. |
| */ |
| this.imgSrcSanitizationWhitelist = function(regexp) { |
| if (isDefined(regexp)) { |
| imgSrcSanitizationWhitelist = regexp; |
| return this; |
| } |
| return imgSrcSanitizationWhitelist; |
| }; |
| |
| this.$get = function() { |
| return function sanitizeUri(uri, isImage) { |
| var regex = isImage ? imgSrcSanitizationWhitelist : aHrefSanitizationWhitelist; |
| var normalizedVal; |
| normalizedVal = urlResolve(uri).href; |
| if (normalizedVal !== '' && !normalizedVal.match(regex)) { |
| return 'unsafe:' + normalizedVal; |
| } |
| return uri; |
| }; |
| }; |
| } |
| |
| /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * |
| * Any commits to this file should be reviewed with security in mind. * |
| * Changes to this file can potentially create security vulnerabilities. * |
| * An approval from 2 Core members with history of modifying * |
| * this file is required. * |
| * * |
| * Does the change somehow allow for arbitrary javascript to be executed? * |
| * Or allows for someone to change the prototype of built-in objects? * |
| * Or gives undesired access to variables likes document or window? * |
| * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
| |
| var $sceMinErr = minErr('$sce'); |
| |
| var SCE_CONTEXTS = { |
| HTML: 'html', |
| CSS: 'css', |
| URL: 'url', |
| // RESOURCE_URL is a subtype of URL used in contexts where a privileged resource is sourced from a |
| // url. (e.g. ng-include, script src, templateUrl) |
| RESOURCE_URL: 'resourceUrl', |
| JS: 'js' |
| }; |
| |
| // Helper functions follow. |
| |
| function adjustMatcher(matcher) { |
| if (matcher === 'self') { |
| return matcher; |
| } else if (isString(matcher)) { |
| // Strings match exactly except for 2 wildcards - '*' and '**'. |
| // '*' matches any character except those from the set ':/.?&'. |
| // '**' matches any character (like .* in a RegExp). |
| // More than 2 *'s raises an error as it's ill defined. |
| if (matcher.indexOf('***') > -1) { |
| throw $sceMinErr('iwcard', |
| 'Illegal sequence *** in string matcher. String: {0}', matcher); |
| } |
| matcher = escapeForRegexp(matcher). |
| replace('\\*\\*', '.*'). |
| replace('\\*', '[^:/.?&;]*'); |
| return new RegExp('^' + matcher + '$'); |
| } else if (isRegExp(matcher)) { |
| // The only other type of matcher allowed is a Regexp. |
| // Match entire URL / disallow partial matches. |
| // Flags are reset (i.e. no global, ignoreCase or multiline) |
| return new RegExp('^' + matcher.source + '$'); |
| } else { |
| throw $sceMinErr('imatcher', |
| 'Matchers may only be "self", string patterns or RegExp objects'); |
| } |
| } |
| |
| |
| function adjustMatchers(matchers) { |
| var adjustedMatchers = []; |
| if (isDefined(matchers)) { |
| forEach(matchers, function(matcher) { |
| adjustedMatchers.push(adjustMatcher(matcher)); |
| }); |
| } |
| return adjustedMatchers; |
| } |
| |
| |
| /** |
| * @ngdoc service |
| * @name $sceDelegate |
| * @kind function |
| * |
| * @description |
| * |
| * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict |
| * Contextual Escaping (SCE)} services to AngularJS. |
| * |
| * Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of |
| * the `$sce` service to customize the way Strict Contextual Escaping works in AngularJS. This is |
| * because, while the `$sce` provides numerous shorthand methods, etc., you really only need to |
| * override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things |
| * work because `$sce` delegates to `$sceDelegate` for these operations. |
| * |
| * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service. |
| * |
| * The default instance of `$sceDelegate` should work out of the box with little pain. While you |
| * can override it completely to change the behavior of `$sce`, the common case would |
| * involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting |
| * your own whitelists and blacklists for trusting URLs used for loading AngularJS resources such as |
| * templates. Refer {@link ng.$sceDelegateProvider#resourceUrlWhitelist |
| * $sceDelegateProvider.resourceUrlWhitelist} and {@link |
| * ng.$sceDelegateProvider#resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} |
| */ |
| |
| /** |
| * @ngdoc provider |
| * @name $sceDelegateProvider |
| * @description |
| * |
| * The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate |
| * $sceDelegate} service. This allows one to get/set the whitelists and blacklists used to ensure |
| * that the URLs used for sourcing Angular templates are safe. Refer {@link |
| * ng.$sceDelegateProvider#resourceUrlWhitelist $sceDelegateProvider.resourceUrlWhitelist} and |
| * {@link ng.$sceDelegateProvider#resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} |
| * |
| * For the general details about this service in Angular, read the main page for {@link ng.$sce |
| * Strict Contextual Escaping (SCE)}. |
| * |
| * **Example**: Consider the following case. <a name="example"></a> |
| * |
| * - your app is hosted at url `http://myapp.example.com/` |
| * - but some of your templates are hosted on other domains you control such as |
| * `http://srv01.assets.example.com/`, `http://srv02.assets.example.com/`, etc. |
| * - and you have an open redirect at `http://myapp.example.com/clickThru?...`. |
| * |
| * Here is what a secure configuration for this scenario might look like: |
| * |
| * ``` |
| * angular.module('myApp', []).config(function($sceDelegateProvider) { |
| * $sceDelegateProvider.resourceUrlWhitelist([ |
| * // Allow same origin resource loads. |
| * 'self', |
| * // Allow loading from our assets domain. Notice the difference between * and **. |
| * 'http://srv*.assets.example.com/**' |
| * ]); |
| * |
| * // The blacklist overrides the whitelist so the open redirect here is blocked. |
| * $sceDelegateProvider.resourceUrlBlacklist([ |
| * 'http://myapp.example.com/clickThru**' |
| * ]); |
| * }); |
| * ``` |
| */ |
| |
| function $SceDelegateProvider() { |
| this.SCE_CONTEXTS = SCE_CONTEXTS; |
| |
| // Resource URLs can also be trusted by policy. |
| var resourceUrlWhitelist = ['self'], |
| resourceUrlBlacklist = []; |
| |
| /** |
| * @ngdoc method |
| * @name $sceDelegateProvider#resourceUrlWhitelist |
| * @kind function |
| * |
| * @param {Array=} whitelist When provided, replaces the resourceUrlWhitelist with the value |
| * provided. This must be an array or null. A snapshot of this array is used so further |
| * changes to the array are ignored. |
| * |
| * Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items |
| * allowed in this array. |
| * |
| * Note: **an empty whitelist array will block all URLs**! |
| * |
| * @return {Array} the currently set whitelist array. |
| * |
| * The **default value** when no whitelist has been explicitly set is `['self']` allowing only |
| * same origin resource requests. |
| * |
| * @description |
| * Sets/Gets the whitelist of trusted resource URLs. |
| */ |
| this.resourceUrlWhitelist = function(value) { |
| if (arguments.length) { |
| resourceUrlWhitelist = adjustMatchers(value); |
| } |
| return resourceUrlWhitelist; |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $sceDelegateProvider#resourceUrlBlacklist |
| * @kind function |
| * |
| * @param {Array=} blacklist When provided, replaces the resourceUrlBlacklist with the value |
| * provided. This must be an array or null. A snapshot of this array is used so further |
| * changes to the array are ignored. |
| * |
| * Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items |
| * allowed in this array. |
| * |
| * The typical usage for the blacklist is to **block |
| * [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as |
| * these would otherwise be trusted but actually return content from the redirected domain. |
| * |
| * Finally, **the blacklist overrides the whitelist** and has the final say. |
| * |
| * @return {Array} the currently set blacklist array. |
| * |
| * The **default value** when no whitelist has been explicitly set is the empty array (i.e. there |
| * is no blacklist.) |
| * |
| * @description |
| * Sets/Gets the blacklist of trusted resource URLs. |
| */ |
| |
| this.resourceUrlBlacklist = function(value) { |
| if (arguments.length) { |
| resourceUrlBlacklist = adjustMatchers(value); |
| } |
| return resourceUrlBlacklist; |
| }; |
| |
| this.$get = ['$injector', function($injector) { |
| |
| var htmlSanitizer = function htmlSanitizer(html) { |
| throw $sceMinErr('unsafe', 'Attempting to use an unsafe value in a safe context.'); |
| }; |
| |
| if ($injector.has('$sanitize')) { |
| htmlSanitizer = $injector.get('$sanitize'); |
| } |
| |
| |
| function matchUrl(matcher, parsedUrl) { |
| if (matcher === 'self') { |
| return urlIsSameOrigin(parsedUrl); |
| } else { |
| // definitely a regex. See adjustMatchers() |
| return !!matcher.exec(parsedUrl.href); |
| } |
| } |
| |
| function isResourceUrlAllowedByPolicy(url) { |
| var parsedUrl = urlResolve(url.toString()); |
| var i, n, allowed = false; |
| // Ensure that at least one item from the whitelist allows this url. |
| for (i = 0, n = resourceUrlWhitelist.length; i < n; i++) { |
| if (matchUrl(resourceUrlWhitelist[i], parsedUrl)) { |
| allowed = true; |
| break; |
| } |
| } |
| if (allowed) { |
| // Ensure that no item from the blacklist blocked this url. |
| for (i = 0, n = resourceUrlBlacklist.length; i < n; i++) { |
| if (matchUrl(resourceUrlBlacklist[i], parsedUrl)) { |
| allowed = false; |
| break; |
| } |
| } |
| } |
| return allowed; |
| } |
| |
| function generateHolderType(Base) { |
| var holderType = function TrustedValueHolderType(trustedValue) { |
| this.$$unwrapTrustedValue = function() { |
| return trustedValue; |
| }; |
| }; |
| if (Base) { |
| holderType.prototype = new Base(); |
| } |
| holderType.prototype.valueOf = function sceValueOf() { |
| return this.$$unwrapTrustedValue(); |
| }; |
| holderType.prototype.toString = function sceToString() { |
| return this.$$unwrapTrustedValue().toString(); |
| }; |
| return holderType; |
| } |
| |
| var trustedValueHolderBase = generateHolderType(), |
| byType = {}; |
| |
| byType[SCE_CONTEXTS.HTML] = generateHolderType(trustedValueHolderBase); |
| byType[SCE_CONTEXTS.CSS] = generateHolderType(trustedValueHolderBase); |
| byType[SCE_CONTEXTS.URL] = generateHolderType(trustedValueHolderBase); |
| byType[SCE_CONTEXTS.JS] = generateHolderType(trustedValueHolderBase); |
| byType[SCE_CONTEXTS.RESOURCE_URL] = generateHolderType(byType[SCE_CONTEXTS.URL]); |
| |
| /** |
| * @ngdoc method |
| * @name $sceDelegate#trustAs |
| * |
| * @description |
| * Returns an object that is trusted by angular for use in specified strict |
| * contextual escaping contexts (such as ng-bind-html, ng-include, any src |
| * attribute interpolation, any dom event binding attribute interpolation |
| * such as for onclick, etc.) that uses the provided value. |
| * See {@link ng.$sce $sce} for enabling strict contextual escaping. |
| * |
| * @param {string} type The kind of context in which this value is safe for use. e.g. url, |
| * resourceUrl, html, js and css. |
| * @param {*} value The value that that should be considered trusted/safe. |
| * @returns {*} A value that can be used to stand in for the provided `value` in places |
| * where Angular expects a $sce.trustAs() return value. |
| */ |
| function trustAs(type, trustedValue) { |
| var Constructor = (byType.hasOwnProperty(type) ? byType[type] : null); |
| if (!Constructor) { |
| throw $sceMinErr('icontext', |
| 'Attempted to trust a value in invalid context. Context: {0}; Value: {1}', |
| type, trustedValue); |
| } |
| if (trustedValue === null || isUndefined(trustedValue) || trustedValue === '') { |
| return trustedValue; |
| } |
| // All the current contexts in SCE_CONTEXTS happen to be strings. In order to avoid trusting |
| // mutable objects, we ensure here that the value passed in is actually a string. |
| if (typeof trustedValue !== 'string') { |
| throw $sceMinErr('itype', |
| 'Attempted to trust a non-string value in a content requiring a string: Context: {0}', |
| type); |
| } |
| return new Constructor(trustedValue); |
| } |
| |
| /** |
| * @ngdoc method |
| * @name $sceDelegate#valueOf |
| * |
| * @description |
| * If the passed parameter had been returned by a prior call to {@link ng.$sceDelegate#trustAs |
| * `$sceDelegate.trustAs`}, returns the value that had been passed to {@link |
| * ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}. |
| * |
| * If the passed parameter is not a value that had been returned by {@link |
| * ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}, returns it as-is. |
| * |
| * @param {*} value The result of a prior {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs`} |
| * call or anything else. |
| * @returns {*} The `value` that was originally provided to {@link ng.$sceDelegate#trustAs |
| * `$sceDelegate.trustAs`} if `value` is the result of such a call. Otherwise, returns |
| * `value` unchanged. |
| */ |
| function valueOf(maybeTrusted) { |
| if (maybeTrusted instanceof trustedValueHolderBase) { |
| return maybeTrusted.$$unwrapTrustedValue(); |
| } else { |
| return maybeTrusted; |
| } |
| } |
| |
| /** |
| * @ngdoc method |
| * @name $sceDelegate#getTrusted |
| * |
| * @description |
| * Takes the result of a {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs`} call and |
| * returns the originally supplied value if the queried context type is a supertype of the |
| * created type. If this condition isn't satisfied, throws an exception. |
| * |
| * @param {string} type The kind of context in which this value is to be used. |
| * @param {*} maybeTrusted The result of a prior {@link ng.$sceDelegate#trustAs |
| * `$sceDelegate.trustAs`} call. |
| * @returns {*} The value the was originally provided to {@link ng.$sceDelegate#trustAs |
| * `$sceDelegate.trustAs`} if valid in this context. Otherwise, throws an exception. |
| */ |
| function getTrusted(type, maybeTrusted) { |
| if (maybeTrusted === null || isUndefined(maybeTrusted) || maybeTrusted === '') { |
| return maybeTrusted; |
| } |
| var constructor = (byType.hasOwnProperty(type) ? byType[type] : null); |
| if (constructor && maybeTrusted instanceof constructor) { |
| return maybeTrusted.$$unwrapTrustedValue(); |
| } |
| // If we get here, then we may only take one of two actions. |
| // 1. sanitize the value for the requested type, or |
| // 2. throw an exception. |
| if (type === SCE_CONTEXTS.RESOURCE_URL) { |
| if (isResourceUrlAllowedByPolicy(maybeTrusted)) { |
| return maybeTrusted; |
| } else { |
| throw $sceMinErr('insecurl', |
| 'Blocked loading resource from url not allowed by $sceDelegate policy. URL: {0}', |
| maybeTrusted.toString()); |
| } |
| } else if (type === SCE_CONTEXTS.HTML) { |
| return htmlSanitizer(maybeTrusted); |
| } |
| throw $sceMinErr('unsafe', 'Attempting to use an unsafe value in a safe context.'); |
| } |
| |
| return { trustAs: trustAs, |
| getTrusted: getTrusted, |
| valueOf: valueOf }; |
| }]; |
| } |
| |
| |
| /** |
| * @ngdoc provider |
| * @name $sceProvider |
| * @description |
| * |
| * The $sceProvider provider allows developers to configure the {@link ng.$sce $sce} service. |
| * - enable/disable Strict Contextual Escaping (SCE) in a module |
| * - override the default implementation with a custom delegate |
| * |
| * Read more about {@link ng.$sce Strict Contextual Escaping (SCE)}. |
| */ |
| |
| /* jshint maxlen: false*/ |
| |
| /** |
| * @ngdoc service |
| * @name $sce |
| * @kind function |
| * |
| * @description |
| * |
| * `$sce` is a service that provides Strict Contextual Escaping services to AngularJS. |
| * |
| * # Strict Contextual Escaping |
| * |
| * Strict Contextual Escaping (SCE) is a mode in which AngularJS requires bindings in certain |
| * contexts to result in a value that is marked as safe to use for that context. One example of |
| * such a context is binding arbitrary html controlled by the user via `ng-bind-html`. We refer |
| * to these contexts as privileged or SCE contexts. |
| * |
| * As of version 1.2, Angular ships with SCE enabled by default. |
| * |
| * Note: When enabled (the default), IE<11 in quirks mode is not supported. In this mode, IE<11 allow |
| * one to execute arbitrary javascript by the use of the expression() syntax. Refer |
| * <http://blogs.msdn.com/b/ie/archive/2008/10/16/ending-expressions.aspx> to learn more about them. |
| * You can ensure your document is in standards mode and not quirks mode by adding `<!doctype html>` |
| * to the top of your HTML document. |
| * |
| * SCE assists in writing code in way that (a) is secure by default and (b) makes auditing for |
| * security vulnerabilities such as XSS, clickjacking, etc. a lot easier. |
| * |
| * Here's an example of a binding in a privileged context: |
| * |
| * ``` |
| * <input ng-model="userHtml" aria-label="User input"> |
| * <div ng-bind-html="userHtml"></div> |
| * ``` |
| * |
| * Notice that `ng-bind-html` is bound to `userHtml` controlled by the user. With SCE |
| * disabled, this application allows the user to render arbitrary HTML into the DIV. |
| * In a more realistic example, one may be rendering user comments, blog articles, etc. via |
| * bindings. (HTML is just one example of a context where rendering user controlled input creates |
| * security vulnerabilities.) |
| * |
| * For the case of HTML, you might use a library, either on the client side, or on the server side, |
| * to sanitize unsafe HTML before binding to the value and rendering it in the document. |
| * |
| * How would you ensure that every place that used these types of bindings was bound to a value that |
| * was sanitized by your library (or returned as safe for rendering by your server?) How can you |
| * ensure that you didn't accidentally delete the line that sanitized the value, or renamed some |
| * properties/fields and forgot to update the binding to the sanitized value? |
| * |
| * To be secure by default, you want to ensure that any such bindings are disallowed unless you can |
| * determine that something explicitly says it's safe to use a value for binding in that |
| * context. You can then audit your code (a simple grep would do) to ensure that this is only done |
| * for those values that you can easily tell are safe - because they were received from your server, |
| * sanitized by your library, etc. You can organize your codebase to help with this - perhaps |
| * allowing only the files in a specific directory to do this. Ensuring that the internal API |
| * exposed by that code doesn't markup arbitrary values as safe then becomes a more manageable task. |
| * |
| * In the case of AngularJS' SCE service, one uses {@link ng.$sce#trustAs $sce.trustAs} |
| * (and shorthand methods such as {@link ng.$sce#trustAsHtml $sce.trustAsHtml}, etc.) to |
| * obtain values that will be accepted by SCE / privileged contexts. |
| * |
| * |
| * ## How does it work? |
| * |
| * In privileged contexts, directives and code will bind to the result of {@link ng.$sce#getTrusted |
| * $sce.getTrusted(context, value)} rather than to the value directly. Directives use {@link |
| * ng.$sce#parseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs the |
| * {@link ng.$sce#getTrusted $sce.getTrusted} behind the scenes on non-constant literals. |
| * |
| * As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link |
| * ng.$sce#parseAsHtml $sce.parseAsHtml(binding expression)}. Here's the actual code (slightly |
| * simplified): |
| * |
| * ``` |
| * var ngBindHtmlDirective = ['$sce', function($sce) { |
| * return function(scope, element, attr) { |
| * scope.$watch($sce.parseAsHtml(attr.ngBindHtml), function(value) { |
| * element.html(value || ''); |
| * }); |
| * }; |
| * }]; |
| * ``` |
| * |
| * ## Impact on loading templates |
| * |
| * This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as |
| * `templateUrl`'s specified by {@link guide/directive directives}. |
| * |
| * By default, Angular only loads templates from the same domain and protocol as the application |
| * document. This is done by calling {@link ng.$sce#getTrustedResourceUrl |
| * $sce.getTrustedResourceUrl} on the template URL. To load templates from other domains and/or |
| * protocols, you may either either {@link ng.$sceDelegateProvider#resourceUrlWhitelist whitelist |
| * them} or {@link ng.$sce#trustAsResourceUrl wrap it} into a trusted value. |
| * |
| * *Please note*: |
| * The browser's |
| * [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest) |
| * and [Cross-Origin Resource Sharing (CORS)](http://www.w3.org/TR/cors/) |
| * policy apply in addition to this and may further restrict whether the template is successfully |
| * loaded. This means that without the right CORS policy, loading templates from a different domain |
| * won't work on all browsers. Also, loading templates from `file://` URL does not work on some |
| * browsers. |
| * |
| * ## This feels like too much overhead |
| * |
| * It's important to remember that SCE only applies to interpolation expressions. |
| * |
| * If your expressions are constant literals, they're automatically trusted and you don't need to |
| * call `$sce.trustAs` on them (remember to include the `ngSanitize` module) (e.g. |
| * `<div ng-bind-html="'<b>implicitly trusted</b>'"></div>`) just works. |
| * |
| * Additionally, `a[href]` and `img[src]` automatically sanitize their URLs and do not pass them |
| * through {@link ng.$sce#getTrusted $sce.getTrusted}. SCE doesn't play a role here. |
| * |
| * The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load |
| * templates in `ng-include` from your application's domain without having to even know about SCE. |
| * It blocks loading templates from other domains or loading templates over http from an https |
| * served document. You can change these by setting your own custom {@link |
| * ng.$sceDelegateProvider#resourceUrlWhitelist whitelists} and {@link |
| * ng.$sceDelegateProvider#resourceUrlBlacklist blacklists} for matching such URLs. |
| * |
| * This significantly reduces the overhead. It is far easier to pay the small overhead and have an |
| * application that's secure and can be audited to verify that with much more ease than bolting |
| * security onto an application later. |
| * |
| * <a name="contexts"></a> |
| * ## What trusted context types are supported? |
| * |
| * | Context | Notes | |
| * |---------------------|----------------| |
| * | `$sce.HTML` | For HTML that's safe to source into the application. The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. If an unsafe value is encountered and the {@link ngSanitize $sanitize} module is present this will sanitize the value instead of throwing an error. | |
| * | `$sce.CSS` | For CSS that's safe to source into the application. Currently unused. Feel free to use it in your own directives. | |
| * | `$sce.URL` | For URLs that are safe to follow as links. Currently unused (`<a href=` and `<img src=` sanitize their urls and don't constitute an SCE context. | |
| * | `$sce.RESOURCE_URL` | For URLs that are not only safe to follow as links, but whose contents are also safe to include in your application. Examples include `ng-include`, `src` / `ngSrc` bindings for tags other than `IMG` (e.g. `IFRAME`, `OBJECT`, etc.) <br><br>Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` does and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` are required. | |
| * | `$sce.JS` | For JavaScript that is safe to execute in your application's context. Currently unused. Feel free to use it in your own directives. | |
| * |
| * ## Format of items in {@link ng.$sceDelegateProvider#resourceUrlWhitelist resourceUrlWhitelist}/{@link ng.$sceDelegateProvider#resourceUrlBlacklist Blacklist} <a name="resourceUrlPatternItem"></a> |
| * |
| * Each element in these arrays must be one of the following: |
| * |
| * - **'self'** |
| * - The special **string**, `'self'`, can be used to match against all URLs of the **same |
| * domain** as the application document using the **same protocol**. |
| * - **String** (except the special value `'self'`) |
| * - The string is matched against the full *normalized / absolute URL* of the resource |
| * being tested (substring matches are not good enough.) |
| * - There are exactly **two wildcard sequences** - `*` and `**`. All other characters |
| * match themselves. |
| * - `*`: matches zero or more occurrences of any character other than one of the following 6 |
| * characters: '`:`', '`/`', '`.`', '`?`', '`&`' and '`;`'. It's a useful wildcard for use |
| * in a whitelist. |
| * - `**`: matches zero or more occurrences of *any* character. As such, it's not |
| * appropriate for use in a scheme, domain, etc. as it would match too much. (e.g. |
| * http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might |
| * not have been the intention.) Its usage at the very end of the path is ok. (e.g. |
| * http://foo.example.com/templates/**). |
| * - **RegExp** (*see caveat below*) |
| * - *Caveat*: While regular expressions are powerful and offer great flexibility, their syntax |
| * (and all the inevitable escaping) makes them *harder to maintain*. It's easy to |
| * accidentally introduce a bug when one updates a complex expression (imho, all regexes should |
| * have good test coverage). For instance, the use of `.` in the regex is correct only in a |
| * small number of cases. A `.` character in the regex used when matching the scheme or a |
| * subdomain could be matched against a `:` or literal `.` that was likely not intended. It |
| * is highly recommended to use the string patterns and only fall back to regular expressions |
| * as a last resort. |
| * - The regular expression must be an instance of RegExp (i.e. not a string.) It is |
| * matched against the **entire** *normalized / absolute URL* of the resource being tested |
| * (even when the RegExp did not have the `^` and `$` codes.) In addition, any flags |
| * present on the RegExp (such as multiline, global, ignoreCase) are ignored. |
| * - If you are generating your JavaScript from some other templating engine (not |
| * recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)), |
| * remember to escape your regular expression (and be aware that you might need more than |
| * one level of escaping depending on your templating engine and the way you interpolated |
| * the value.) Do make use of your platform's escaping mechanism as it might be good |
| * enough before coding your own. E.g. Ruby has |
| * [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape) |
| * and Python has [re.escape](http://docs.python.org/library/re.html#re.escape). |
| * Javascript lacks a similar built in function for escaping. Take a look at Google |
| * Closure library's [goog.string.regExpEscape(s)]( |
| * http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962). |
| * |
| * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example. |
| * |
| * ## Show me an example using SCE. |
| * |
| * <example module="mySceApp" deps="angular-sanitize.js"> |
| * <file name="index.html"> |
| * <div ng-controller="AppController as myCtrl"> |
| * <i ng-bind-html="myCtrl.explicitlyTrustedHtml" id="explicitlyTrustedHtml"></i><br><br> |
| * <b>User comments</b><br> |
| * By default, HTML that isn't explicitly trusted (e.g. Alice's comment) is sanitized when |
| * $sanitize is available. If $sanitize isn't available, this results in an error instead of an |
| * exploit. |
| * <div class="well"> |
| * <div ng-repeat="userComment in myCtrl.userComments"> |
| * <b>{{userComment.name}}</b>: |
| * <span ng-bind-html="userComment.htmlComment" class="htmlComment"></span> |
| * <br> |
| * </div> |
| * </div> |
| * </div> |
| * </file> |
| * |
| * <file name="script.js"> |
| * angular.module('mySceApp', ['ngSanitize']) |
| * .controller('AppController', ['$http', '$templateCache', '$sce', |
| * function($http, $templateCache, $sce) { |
| * var self = this; |
| * $http.get("test_data.json", {cache: $templateCache}).success(function(userComments) { |
| * self.userComments = userComments; |
| * }); |
| * self.explicitlyTrustedHtml = $sce.trustAsHtml( |
| * '<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' + |
| * 'sanitization."">Hover over this text.</span>'); |
| * }]); |
| * </file> |
| * |
| * <file name="test_data.json"> |
| * [ |
| * { "name": "Alice", |
| * "htmlComment": |
| * "<span onmouseover='this.textContent=\"PWN3D!\"'>Is <i>anyone</i> reading this?</span>" |
| * }, |
| * { "name": "Bob", |
| * "htmlComment": "<i>Yes!</i> Am I the only other one?" |
| * } |
| * ] |
| * </file> |
| * |
| * <file name="protractor.js" type="protractor"> |
| * describe('SCE doc demo', function() { |
| * it('should sanitize untrusted values', function() { |
| * expect(element.all(by.css('.htmlComment')).first().getInnerHtml()) |
| * .toBe('<span>Is <i>anyone</i> reading this?</span>'); |
| * }); |
| * |
| * it('should NOT sanitize explicitly trusted values', function() { |
| * expect(element(by.id('explicitlyTrustedHtml')).getInnerHtml()).toBe( |
| * '<span onmouseover="this.textContent="Explicitly trusted HTML bypasses ' + |
| * 'sanitization."">Hover over this text.</span>'); |
| * }); |
| * }); |
| * </file> |
| * </example> |
| * |
| * |
| * |
| * ## Can I disable SCE completely? |
| * |
| * Yes, you can. However, this is strongly discouraged. SCE gives you a lot of security benefits |
| * for little coding overhead. It will be much harder to take an SCE disabled application and |
| * either secure it on your own or enable SCE at a later stage. It might make sense to disable SCE |
| * for cases where you have a lot of existing code that was written before SCE was introduced and |
| * you're migrating them a module at a time. |
| * |
| * That said, here's how you can completely disable SCE: |
| * |
| * ``` |
| * angular.module('myAppWithSceDisabledmyApp', []).config(function($sceProvider) { |
| * // Completely disable SCE. For demonstration purposes only! |
| * // Do not use in new projects. |
| * $sceProvider.enabled(false); |
| * }); |
| * ``` |
| * |
| */ |
| /* jshint maxlen: 100 */ |
| |
| function $SceProvider() { |
| var enabled = true; |
| |
| /** |
| * @ngdoc method |
| * @name $sceProvider#enabled |
| * @kind function |
| * |
| * @param {boolean=} value If provided, then enables/disables SCE. |
| * @return {boolean} true if SCE is enabled, false otherwise. |
| * |
| * @description |
| * Enables/disables SCE and returns the current value. |
| */ |
| this.enabled = function(value) { |
| if (arguments.length) { |
| enabled = !!value; |
| } |
| return enabled; |
| }; |
| |
| |
| /* Design notes on the default implementation for SCE. |
| * |
| * The API contract for the SCE delegate |
| * ------------------------------------- |
| * The SCE delegate object must provide the following 3 methods: |
| * |
| * - trustAs(contextEnum, value) |
| * This method is used to tell the SCE service that the provided value is OK to use in the |
| * contexts specified by contextEnum. It must return an object that will be accepted by |
| * getTrusted() for a compatible contextEnum and return this value. |
| * |
| * - valueOf(value) |
| * For values that were not produced by trustAs(), return them as is. For values that were |
| * produced by trustAs(), return the corresponding input value to trustAs. Basically, if |
| * trustAs is wrapping the given values into some type, this operation unwraps it when given |
| * such a value. |
| * |
| * - getTrusted(contextEnum, value) |
| * This function should return the a value that is safe to use in the context specified by |
| * contextEnum or throw and exception otherwise. |
| * |
| * NOTE: This contract deliberately does NOT state that values returned by trustAs() must be |
| * opaque or wrapped in some holder object. That happens to be an implementation detail. For |
| * instance, an implementation could maintain a registry of all trusted objects by context. In |
| * such a case, trustAs() would return the same object that was passed in. getTrusted() would |
| * return the same object passed in if it was found in the registry under a compatible context or |
| * throw an exception otherwise. An implementation might only wrap values some of the time based |
| * on some criteria. getTrusted() might return a value and not throw an exception for special |
| * constants or objects even if not wrapped. All such implementations fulfill this contract. |
| * |
| * |
| * A note on the inheritance model for SCE contexts |
| * ------------------------------------------------ |
| * I've used inheritance and made RESOURCE_URL wrapped types a subtype of URL wrapped types. This |
| * is purely an implementation details. |
| * |
| * The contract is simply this: |
| * |
| * getTrusted($sce.RESOURCE_URL, value) succeeding implies that getTrusted($sce.URL, value) |
| * will also succeed. |
| * |
| * Inheritance happens to capture this in a natural way. In some future, we |
| * may not use inheritance anymore. That is OK because no code outside of |
| * sce.js and sceSpecs.js would need to be aware of this detail. |
| */ |
| |
| this.$get = ['$parse', '$sceDelegate', function( |
| $parse, $sceDelegate) { |
| // Prereq: Ensure that we're not running in IE<11 quirks mode. In that mode, IE < 11 allow |
| // the "expression(javascript expression)" syntax which is insecure. |
| if (enabled && msie < 8) { |
| throw $sceMinErr('iequirks', |
| 'Strict Contextual Escaping does not support Internet Explorer version < 11 in quirks ' + |
| 'mode. You can fix this by adding the text <!doctype html> to the top of your HTML ' + |
| 'document. See http://docs.angularjs.org/api/ng.$sce for more information.'); |
| } |
| |
| var sce = shallowCopy(SCE_CONTEXTS); |
| |
| /** |
| * @ngdoc method |
| * @name $sce#isEnabled |
| * @kind function |
| * |
| * @return {Boolean} true if SCE is enabled, false otherwise. If you want to set the value, you |
| * have to do it at module config time on {@link ng.$sceProvider $sceProvider}. |
| * |
| * @description |
| * Returns a boolean indicating if SCE is enabled. |
| */ |
| sce.isEnabled = function() { |
| return enabled; |
| }; |
| sce.trustAs = $sceDelegate.trustAs; |
| sce.getTrusted = $sceDelegate.getTrusted; |
| sce.valueOf = $sceDelegate.valueOf; |
| |
| if (!enabled) { |
| sce.trustAs = sce.getTrusted = function(type, value) { return value; }; |
| sce.valueOf = identity; |
| } |
| |
| /** |
| * @ngdoc method |
| * @name $sce#parseAs |
| * |
| * @description |
| * Converts Angular {@link guide/expression expression} into a function. This is like {@link |
| * ng.$parse $parse} and is identical when the expression is a literal constant. Otherwise, it |
| * wraps the expression in a call to {@link ng.$sce#getTrusted $sce.getTrusted(*type*, |
| * *result*)} |
| * |
| * @param {string} type The kind of SCE context in which this result will be used. |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| */ |
| sce.parseAs = function sceParseAs(type, expr) { |
| var parsed = $parse(expr); |
| if (parsed.literal && parsed.constant) { |
| return parsed; |
| } else { |
| return $parse(expr, function(value) { |
| return sce.getTrusted(type, value); |
| }); |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name $sce#trustAs |
| * |
| * @description |
| * Delegates to {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs`}. As such, |
| * returns an object that is trusted by angular for use in specified strict contextual |
| * escaping contexts (such as ng-bind-html, ng-include, any src attribute |
| * interpolation, any dom event binding attribute interpolation such as for onclick, etc.) |
| * that uses the provided value. See * {@link ng.$sce $sce} for enabling strict contextual |
| * escaping. |
| * |
| * @param {string} type The kind of context in which this value is safe for use. e.g. url, |
| * resourceUrl, html, js and css. |
| * @param {*} value The value that that should be considered trusted/safe. |
| * @returns {*} A value that can be used to stand in for the provided `value` in places |
| * where Angular expects a $sce.trustAs() return value. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#trustAsHtml |
| * |
| * @description |
| * Shorthand method. `$sce.trustAsHtml(value)` → |
| * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.HTML, value)`} |
| * |
| * @param {*} value The value to trustAs. |
| * @returns {*} An object that can be passed to {@link ng.$sce#getTrustedHtml |
| * $sce.getTrustedHtml(value)} to obtain the original value. (privileged directives |
| * only accept expressions that are either literal constants or are the |
| * return value of {@link ng.$sce#trustAs $sce.trustAs}.) |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#trustAsUrl |
| * |
| * @description |
| * Shorthand method. `$sce.trustAsUrl(value)` → |
| * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.URL, value)`} |
| * |
| * @param {*} value The value to trustAs. |
| * @returns {*} An object that can be passed to {@link ng.$sce#getTrustedUrl |
| * $sce.getTrustedUrl(value)} to obtain the original value. (privileged directives |
| * only accept expressions that are either literal constants or are the |
| * return value of {@link ng.$sce#trustAs $sce.trustAs}.) |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#trustAsResourceUrl |
| * |
| * @description |
| * Shorthand method. `$sce.trustAsResourceUrl(value)` → |
| * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.RESOURCE_URL, value)`} |
| * |
| * @param {*} value The value to trustAs. |
| * @returns {*} An object that can be passed to {@link ng.$sce#getTrustedResourceUrl |
| * $sce.getTrustedResourceUrl(value)} to obtain the original value. (privileged directives |
| * only accept expressions that are either literal constants or are the return |
| * value of {@link ng.$sce#trustAs $sce.trustAs}.) |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#trustAsJs |
| * |
| * @description |
| * Shorthand method. `$sce.trustAsJs(value)` → |
| * {@link ng.$sceDelegate#trustAs `$sceDelegate.trustAs($sce.JS, value)`} |
| * |
| * @param {*} value The value to trustAs. |
| * @returns {*} An object that can be passed to {@link ng.$sce#getTrustedJs |
| * $sce.getTrustedJs(value)} to obtain the original value. (privileged directives |
| * only accept expressions that are either literal constants or are the |
| * return value of {@link ng.$sce#trustAs $sce.trustAs}.) |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#getTrusted |
| * |
| * @description |
| * Delegates to {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted`}. As such, |
| * takes the result of a {@link ng.$sce#trustAs `$sce.trustAs`}() call and returns the |
| * originally supplied value if the queried context type is a supertype of the created type. |
| * If this condition isn't satisfied, throws an exception. |
| * |
| * @param {string} type The kind of context in which this value is to be used. |
| * @param {*} maybeTrusted The result of a prior {@link ng.$sce#trustAs `$sce.trustAs`} |
| * call. |
| * @returns {*} The value the was originally provided to |
| * {@link ng.$sce#trustAs `$sce.trustAs`} if valid in this context. |
| * Otherwise, throws an exception. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#getTrustedHtml |
| * |
| * @description |
| * Shorthand method. `$sce.getTrustedHtml(value)` → |
| * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.HTML, value)`} |
| * |
| * @param {*} value The value to pass to `$sce.getTrusted`. |
| * @returns {*} The return value of `$sce.getTrusted($sce.HTML, value)` |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#getTrustedCss |
| * |
| * @description |
| * Shorthand method. `$sce.getTrustedCss(value)` → |
| * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.CSS, value)`} |
| * |
| * @param {*} value The value to pass to `$sce.getTrusted`. |
| * @returns {*} The return value of `$sce.getTrusted($sce.CSS, value)` |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#getTrustedUrl |
| * |
| * @description |
| * Shorthand method. `$sce.getTrustedUrl(value)` → |
| * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.URL, value)`} |
| * |
| * @param {*} value The value to pass to `$sce.getTrusted`. |
| * @returns {*} The return value of `$sce.getTrusted($sce.URL, value)` |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#getTrustedResourceUrl |
| * |
| * @description |
| * Shorthand method. `$sce.getTrustedResourceUrl(value)` → |
| * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.RESOURCE_URL, value)`} |
| * |
| * @param {*} value The value to pass to `$sceDelegate.getTrusted`. |
| * @returns {*} The return value of `$sce.getTrusted($sce.RESOURCE_URL, value)` |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#getTrustedJs |
| * |
| * @description |
| * Shorthand method. `$sce.getTrustedJs(value)` → |
| * {@link ng.$sceDelegate#getTrusted `$sceDelegate.getTrusted($sce.JS, value)`} |
| * |
| * @param {*} value The value to pass to `$sce.getTrusted`. |
| * @returns {*} The return value of `$sce.getTrusted($sce.JS, value)` |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#parseAsHtml |
| * |
| * @description |
| * Shorthand method. `$sce.parseAsHtml(expression string)` → |
| * {@link ng.$sce#parseAs `$sce.parseAs($sce.HTML, value)`} |
| * |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#parseAsCss |
| * |
| * @description |
| * Shorthand method. `$sce.parseAsCss(value)` → |
| * {@link ng.$sce#parseAs `$sce.parseAs($sce.CSS, value)`} |
| * |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#parseAsUrl |
| * |
| * @description |
| * Shorthand method. `$sce.parseAsUrl(value)` → |
| * {@link ng.$sce#parseAs `$sce.parseAs($sce.URL, value)`} |
| * |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#parseAsResourceUrl |
| * |
| * @description |
| * Shorthand method. `$sce.parseAsResourceUrl(value)` → |
| * {@link ng.$sce#parseAs `$sce.parseAs($sce.RESOURCE_URL, value)`} |
| * |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| */ |
| |
| /** |
| * @ngdoc method |
| * @name $sce#parseAsJs |
| * |
| * @description |
| * Shorthand method. `$sce.parseAsJs(value)` → |
| * {@link ng.$sce#parseAs `$sce.parseAs($sce.JS, value)`} |
| * |
| * @param {string} expression String expression to compile. |
| * @returns {function(context, locals)} a function which represents the compiled expression: |
| * |
| * * `context` – `{object}` – an object against which any expressions embedded in the strings |
| * are evaluated against (typically a scope object). |
| * * `locals` – `{object=}` – local variables context object, useful for overriding values in |
| * `context`. |
| */ |
| |
| // Shorthand delegations. |
| var parse = sce.parseAs, |
| getTrusted = sce.getTrusted, |
| trustAs = sce.trustAs; |
| |
| forEach(SCE_CONTEXTS, function(enumValue, name) { |
| var lName = lowercase(name); |
| sce[camelCase("parse_as_" + lName)] = function(expr) { |
| return parse(enumValue, expr); |
| }; |
| sce[camelCase("get_trusted_" + lName)] = function(value) { |
| return getTrusted(enumValue, value); |
| }; |
| sce[camelCase("trust_as_" + lName)] = function(value) { |
| return trustAs(enumValue, value); |
| }; |
| }); |
| |
| return sce; |
| }]; |
| } |
| |
| /** |
| * !!! This is an undocumented "private" service !!! |
| * |
| * @name $sniffer |
| * @requires $window |
| * @requires $document |
| * |
| * @property {boolean} history Does the browser support html5 history api ? |
| * @property {boolean} transitions Does the browser support CSS transition events ? |
| * @property {boolean} animations Does the browser support CSS animation events ? |
| * |
| * @description |
| * This is very simple implementation of testing browser's features. |
| */ |
| function $SnifferProvider() { |
| this.$get = ['$window', '$document', function($window, $document) { |
| var eventSupport = {}, |
| android = |
| toInt((/android (\d+)/.exec(lowercase(($window.navigator || {}).userAgent)) || [])[1]), |
| boxee = /Boxee/i.test(($window.navigator || {}).userAgent), |
| document = $document[0] || {}, |
| vendorPrefix, |
| vendorRegex = /^(Moz|webkit|ms)(?=[A-Z])/, |
| bodyStyle = document.body && document.body.style, |
| transitions = false, |
| animations = false, |
| match; |
| |
| if (bodyStyle) { |
| for (var prop in bodyStyle) { |
| if (match = vendorRegex.exec(prop)) { |
| vendorPrefix = match[0]; |
| vendorPrefix = vendorPrefix.substr(0, 1).toUpperCase() + vendorPrefix.substr(1); |
| break; |
| } |
| } |
| |
| if (!vendorPrefix) { |
| vendorPrefix = ('WebkitOpacity' in bodyStyle) && 'webkit'; |
| } |
| |
| transitions = !!(('transition' in bodyStyle) || (vendorPrefix + 'Transition' in bodyStyle)); |
| animations = !!(('animation' in bodyStyle) || (vendorPrefix + 'Animation' in bodyStyle)); |
| |
| if (android && (!transitions || !animations)) { |
| transitions = isString(bodyStyle.webkitTransition); |
| animations = isString(bodyStyle.webkitAnimation); |
| } |
| } |
| |
| |
| return { |
| // Android has history.pushState, but it does not update location correctly |
| // so let's not use the history API at all. |
| // http://code.google.com/p/android/issues/detail?id=17471 |
| // https://github.com/angular/angular.js/issues/904 |
| |
| // older webkit browser (533.9) on Boxee box has exactly the same problem as Android has |
| // so let's not use the history API also |
| // We are purposefully using `!(android < 4)` to cover the case when `android` is undefined |
| // jshint -W018 |
| history: !!($window.history && $window.history.pushState && !(android < 4) && !boxee), |
| // jshint +W018 |
| hasEvent: function(event) { |
| // IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have |
| // it. In particular the event is not fired when backspace or delete key are pressed or |
| // when cut operation is performed. |
| // IE10+ implements 'input' event but it erroneously fires under various situations, |
| // e.g. when placeholder changes, or a form is focused. |
| if (event === 'input' && msie <= 11) return false; |
| |
| if (isUndefined(eventSupport[event])) { |
| var divElm = document.createElement('div'); |
| eventSupport[event] = 'on' + event in divElm; |
| } |
| |
| return eventSupport[event]; |
| }, |
| csp: csp(), |
| vendorPrefix: vendorPrefix, |
| transitions: transitions, |
| animations: animations, |
| android: android |
| }; |
| }]; |
| } |
| |
| var $compileMinErr = minErr('$compile'); |
| |
| /** |
| * @ngdoc service |
| * @name $templateRequest |
| * |
| * @description |
| * The `$templateRequest` service runs security checks then downloads the provided template using |
| * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request |
| * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the |
| * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the |
| * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted |
| * when `tpl` is of type string and `$templateCache` has the matching entry. |
| * |
| * @param {string|TrustedResourceUrl} tpl The HTTP request template URL |
| * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty |
| * |
| * @return {Promise} a promise for the HTTP response data of the given URL. |
| * |
| * @property {number} totalPendingRequests total amount of pending template requests being downloaded. |
| */ |
| function $TemplateRequestProvider() { |
| this.$get = ['$templateCache', '$http', '$q', '$sce', function($templateCache, $http, $q, $sce) { |
| function handleRequestFn(tpl, ignoreRequestError) { |
| handleRequestFn.totalPendingRequests++; |
| |
| // We consider the template cache holds only trusted templates, so |
| // there's no need to go through whitelisting again for keys that already |
| // are included in there. This also makes Angular accept any script |
| // directive, no matter its name. However, we still need to unwrap trusted |
| // types. |
| if (!isString(tpl) || !$templateCache.get(tpl)) { |
| tpl = $sce.getTrustedResourceUrl(tpl); |
| } |
| |
| var transformResponse = $http.defaults && $http.defaults.transformResponse; |
| |
| if (isArray(transformResponse)) { |
| transformResponse = transformResponse.filter(function(transformer) { |
| return transformer !== defaultHttpResponseTransform; |
| }); |
| } else if (transformResponse === defaultHttpResponseTransform) { |
| transformResponse = null; |
| } |
| |
| var httpOptions = { |
| cache: $templateCache, |
| transformResponse: transformResponse |
| }; |
| |
| return $http.get(tpl, httpOptions) |
| ['finally'](function() { |
| handleRequestFn.totalPendingRequests--; |
| }) |
| .then(function(response) { |
| $templateCache.put(tpl, response.data); |
| return response.data; |
| }, handleError); |
| |
| function handleError(resp) { |
| if (!ignoreRequestError) { |
| throw $compileMinErr('tpload', 'Failed to load template: {0} (HTTP status: {1} {2})', |
| tpl, resp.status, resp.statusText); |
| } |
| return $q.reject(resp); |
| } |
| } |
| |
| handleRequestFn.totalPendingRequests = 0; |
| |
| return handleRequestFn; |
| }]; |
| } |
| |
| function $$TestabilityProvider() { |
| this.$get = ['$rootScope', '$browser', '$location', |
| function($rootScope, $browser, $location) { |
| |
| /** |
| * @name $testability |
| * |
| * @description |
| * The private $$testability service provides a collection of methods for use when debugging |
| * or by automated test and debugging tools. |
| */ |
| var testability = {}; |
| |
| /** |
| * @name $$testability#findBindings |
| * |
| * @description |
| * Returns an array of elements that are bound (via ng-bind or {{}}) |
| * to expressions matching the input. |
| * |
| * @param {Element} element The element root to search from. |
| * @param {string} expression The binding expression to match. |
| * @param {boolean} opt_exactMatch If true, only returns exact matches |
| * for the expression. Filters and whitespace are ignored. |
| */ |
| testability.findBindings = function(element, expression, opt_exactMatch) { |
| var bindings = element.getElementsByClassName('ng-binding'); |
| var matches = []; |
| forEach(bindings, function(binding) { |
| var dataBinding = angular.element(binding).data('$binding'); |
| if (dataBinding) { |
| forEach(dataBinding, function(bindingName) { |
| if (opt_exactMatch) { |
| var matcher = new RegExp('(^|\\s)' + escapeForRegexp(expression) + '(\\s|\\||$)'); |
| if (matcher.test(bindingName)) { |
| matches.push(binding); |
| } |
| } else { |
| if (bindingName.indexOf(expression) != -1) { |
| matches.push(binding); |
| } |
| } |
| }); |
| } |
| }); |
| return matches; |
| }; |
| |
| /** |
| * @name $$testability#findModels |
| * |
| * @description |
| * Returns an array of elements that are two-way found via ng-model to |
| * expressions matching the input. |
| * |
| * @param {Element} element The element root to search from. |
| * @param {string} expression The model expression to match. |
| * @param {boolean} opt_exactMatch If true, only returns exact matches |
| * for the expression. |
| */ |
| testability.findModels = function(element, expression, opt_exactMatch) { |
| var prefixes = ['ng-', 'data-ng-', 'ng\\:']; |
| for (var p = 0; p < prefixes.length; ++p) { |
| var attributeEquals = opt_exactMatch ? '=' : '*='; |
| var selector = '[' + prefixes[p] + 'model' + attributeEquals + '"' + expression + '"]'; |
| var elements = element.querySelectorAll(selector); |
| if (elements.length) { |
| return elements; |
| } |
| } |
| }; |
| |
| /** |
| * @name $$testability#getLocation |
| * |
| * @description |
| * Shortcut for getting the location in a browser agnostic way. Returns |
| * the path, search, and hash. (e.g. /path?a=b#hash) |
| */ |
| testability.getLocation = function() { |
| return $location.url(); |
| }; |
| |
| /** |
| * @name $$testability#setLocation |
| * |
| * @description |
| * Shortcut for navigating to a location without doing a full page reload. |
| * |
| * @param {string} url The location url (path, search and hash, |
| * e.g. /path?a=b#hash) to go to. |
| */ |
| testability.setLocation = function(url) { |
| if (url !== $location.url()) { |
| $location.url(url); |
| $rootScope.$digest(); |
| } |
| }; |
| |
| /** |
| * @name $$testability#whenStable |
| * |
| * @description |
| * Calls the callback when $timeout and $http requests are completed. |
| * |
| * @param {function} callback |
| */ |
| testability.whenStable = function(callback) { |
| $browser.notifyWhenNoOutstandingRequests(callback); |
| }; |
| |
| return testability; |
| }]; |
| } |
| |
| function $TimeoutProvider() { |
| this.$get = ['$rootScope', '$browser', '$q', '$$q', '$exceptionHandler', |
| function($rootScope, $browser, $q, $$q, $exceptionHandler) { |
| |
| var deferreds = {}; |
| |
| |
| /** |
| * @ngdoc service |
| * @name $timeout |
| * |
| * @description |
| * Angular's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch |
| * block and delegates any exceptions to |
| * {@link ng.$exceptionHandler $exceptionHandler} service. |
| * |
| * The return value of calling `$timeout` is a promise, which will be resolved when |
| * the delay has passed and the timeout function, if provided, is executed. |
| * |
| * To cancel a timeout request, call `$timeout.cancel(promise)`. |
| * |
| * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to |
| * synchronously flush the queue of deferred functions. |
| * |
| * If you only want a promise that will be resolved after some specified delay |
| * then you can call `$timeout` without the `fn` function. |
| * |
| * @param {function()=} fn A function, whose execution should be delayed. |
| * @param {number=} [delay=0] Delay in milliseconds. |
| * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise |
| * will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block. |
| * @param {...*=} Pass additional parameters to the executed function. |
| * @returns {Promise} Promise that will be resolved when the timeout is reached. The value this |
| * promise will be resolved with is the return value of the `fn` function. |
| * |
| */ |
| function timeout(fn, delay, invokeApply) { |
| if (!isFunction(fn)) { |
| invokeApply = delay; |
| delay = fn; |
| fn = noop; |
| } |
| |
| var args = sliceArgs(arguments, 3), |
| skipApply = (isDefined(invokeApply) && !invokeApply), |
| deferred = (skipApply ? $$q : $q).defer(), |
| promise = deferred.promise, |
| timeoutId; |
| |
| timeoutId = $browser.defer(function() { |
| try { |
| deferred.resolve(fn.apply(null, args)); |
| } catch (e) { |
| deferred.reject(e); |
| $exceptionHandler(e); |
| } |
| finally { |
| delete deferreds[promise.$$timeoutId]; |
| } |
| |
| if (!skipApply) $rootScope.$apply(); |
| }, delay); |
| |
| promise.$$timeoutId = timeoutId; |
| deferreds[timeoutId] = deferred; |
| |
| return promise; |
| } |
| |
| |
| /** |
| * @ngdoc method |
| * @name $timeout#cancel |
| * |
| * @description |
| * Cancels a task associated with the `promise`. As a result of this, the promise will be |
| * resolved with a rejection. |
| * |
| * @param {Promise=} promise Promise returned by the `$timeout` function. |
| * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully |
| * canceled. |
| */ |
| timeout.cancel = function(promise) { |
| if (promise && promise.$$timeoutId in deferreds) { |
| deferreds[promise.$$timeoutId].reject('canceled'); |
| delete deferreds[promise.$$timeoutId]; |
| return $browser.defer.cancel(promise.$$timeoutId); |
| } |
| return false; |
| }; |
| |
| return timeout; |
| }]; |
| } |
| |
| // NOTE: The usage of window and document instead of $window and $document here is |
| // deliberate. This service depends on the specific behavior of anchor nodes created by the |
| // browser (resolving and parsing URLs) that is unlikely to be provided by mock objects and |
| // cause us to break tests. In addition, when the browser resolves a URL for XHR, it |
| // doesn't know about mocked locations and resolves URLs to the real document - which is |
| // exactly the behavior needed here. There is little value is mocking these out for this |
| // service. |
| var urlParsingNode = document.createElement("a"); |
| var originUrl = urlResolve(window.location.href); |
| |
| |
| /** |
| * |
| * Implementation Notes for non-IE browsers |
| * ---------------------------------------- |
| * Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM, |
| * results both in the normalizing and parsing of the URL. Normalizing means that a relative |
| * URL will be resolved into an absolute URL in the context of the application document. |
| * Parsing means that the anchor node's host, hostname, protocol, port, pathname and related |
| * properties are all populated to reflect the normalized URL. This approach has wide |
| * compatibility - Safari 1+, Mozilla 1+, Opera 7+,e etc. See |
| * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html |
| * |
| * Implementation Notes for IE |
| * --------------------------- |
| * IE <= 10 normalizes the URL when assigned to the anchor node similar to the other |
| * browsers. However, the parsed components will not be set if the URL assigned did not specify |
| * them. (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.) We |
| * work around that by performing the parsing in a 2nd step by taking a previously normalized |
| * URL (e.g. by assigning to a.href) and assigning it a.href again. This correctly populates the |
| * properties such as protocol, hostname, port, etc. |
| * |
| * References: |
| * http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement |
| * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html |
| * http://url.spec.whatwg.org/#urlutils |
| * https://github.com/angular/angular.js/pull/2902 |
| * http://james.padolsey.com/javascript/parsing-urls-with-the-dom/ |
| * |
| * @kind function |
| * @param {string} url The URL to be parsed. |
| * @description Normalizes and parses a URL. |
| * @returns {object} Returns the normalized URL as a dictionary. |
| * |
| * | member name | Description | |
| * |---------------|----------------| |
| * | href | A normalized version of the provided URL if it was not an absolute URL | |
| * | protocol | The protocol including the trailing colon | |
| * | host | The host and port (if the port is non-default) of the normalizedUrl | |
| * | search | The search params, minus the question mark | |
| * | hash | The hash string, minus the hash symbol |
| * | hostname | The hostname |
| * | port | The port, without ":" |
| * | pathname | The pathname, beginning with "/" |
| * |
| */ |
| function urlResolve(url) { |
| var href = url; |
| |
| if (msie) { |
| // Normalize before parse. Refer Implementation Notes on why this is |
| // done in two steps on IE. |
| urlParsingNode.setAttribute("href", href); |
| href = urlParsingNode.href; |
| } |
| |
| urlParsingNode.setAttribute('href', href); |
| |
| // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils |
| return { |
| href: urlParsingNode.href, |
| protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', |
| host: urlParsingNode.host, |
| search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', |
| hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', |
| hostname: urlParsingNode.hostname, |
| port: urlParsingNode.port, |
| pathname: (urlParsingNode.pathname.charAt(0) === '/') |
| ? urlParsingNode.pathname |
| : '/' + urlParsingNode.pathname |
| }; |
| } |
| |
| /** |
| * Parse a request URL and determine whether this is a same-origin request as the application document. |
| * |
| * @param {string|object} requestUrl The url of the request as a string that will be resolved |
| * or a parsed URL object. |
| * @returns {boolean} Whether the request is for the same origin as the application document. |
| */ |
| function urlIsSameOrigin(requestUrl) { |
| var parsed = (isString(requestUrl)) ? urlResolve(requestUrl) : requestUrl; |
| return (parsed.protocol === originUrl.protocol && |
| parsed.host === originUrl.host); |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $window |
| * |
| * @description |
| * A reference to the browser's `window` object. While `window` |
| * is globally available in JavaScript, it causes testability problems, because |
| * it is a global variable. In angular we always refer to it through the |
| * `$window` service, so it may be overridden, removed or mocked for testing. |
| * |
| * Expressions, like the one defined for the `ngClick` directive in the example |
| * below, are evaluated with respect to the current scope. Therefore, there is |
| * no risk of inadvertently coding in a dependency on a global value in such an |
| * expression. |
| * |
| * @example |
| <example module="windowExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('windowExample', []) |
| .controller('ExampleController', ['$scope', '$window', function($scope, $window) { |
| $scope.greeting = 'Hello, World!'; |
| $scope.doGreeting = function(greeting) { |
| $window.alert(greeting); |
| }; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <input type="text" ng-model="greeting" aria-label="greeting" /> |
| <button ng-click="doGreeting(greeting)">ALERT</button> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should display the greeting in the input box', function() { |
| element(by.model('greeting')).sendKeys('Hello, E2E Tests'); |
| // If we click the button it will block the test runner |
| // element(':button').click(); |
| }); |
| </file> |
| </example> |
| */ |
| function $WindowProvider() { |
| this.$get = valueFn(window); |
| } |
| |
| /** |
| * @name $$cookieReader |
| * @requires $document |
| * |
| * @description |
| * This is a private service for reading cookies used by $http and ngCookies |
| * |
| * @return {Object} a key/value map of the current cookies |
| */ |
| function $$CookieReader($document) { |
| var rawDocument = $document[0] || {}; |
| var lastCookies = {}; |
| var lastCookieString = ''; |
| |
| function safeDecodeURIComponent(str) { |
| try { |
| return decodeURIComponent(str); |
| } catch (e) { |
| return str; |
| } |
| } |
| |
| return function() { |
| var cookieArray, cookie, i, index, name; |
| var currentCookieString = rawDocument.cookie || ''; |
| |
| if (currentCookieString !== lastCookieString) { |
| lastCookieString = currentCookieString; |
| cookieArray = lastCookieString.split('; '); |
| lastCookies = {}; |
| |
| for (i = 0; i < cookieArray.length; i++) { |
| cookie = cookieArray[i]; |
| index = cookie.indexOf('='); |
| if (index > 0) { //ignore nameless cookies |
| name = safeDecodeURIComponent(cookie.substring(0, index)); |
| // the first value that is seen for a cookie is the most |
| // specific one. values for the same cookie name that |
| // follow are for less specific paths. |
| if (isUndefined(lastCookies[name])) { |
| lastCookies[name] = safeDecodeURIComponent(cookie.substring(index + 1)); |
| } |
| } |
| } |
| } |
| return lastCookies; |
| }; |
| } |
| |
| $$CookieReader.$inject = ['$document']; |
| |
| function $$CookieReaderProvider() { |
| this.$get = $$CookieReader; |
| } |
| |
| /* global currencyFilter: true, |
| dateFilter: true, |
| filterFilter: true, |
| jsonFilter: true, |
| limitToFilter: true, |
| lowercaseFilter: true, |
| numberFilter: true, |
| orderByFilter: true, |
| uppercaseFilter: true, |
| */ |
| |
| /** |
| * @ngdoc provider |
| * @name $filterProvider |
| * @description |
| * |
| * Filters are just functions which transform input to an output. However filters need to be |
| * Dependency Injected. To achieve this a filter definition consists of a factory function which is |
| * annotated with dependencies and is responsible for creating a filter function. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`. |
| * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace |
| * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores |
| * (`myapp_subsection_filterx`). |
| * </div> |
| * |
| * ```js |
| * // Filter registration |
| * function MyModule($provide, $filterProvider) { |
| * // create a service to demonstrate injection (not always needed) |
| * $provide.value('greet', function(name){ |
| * return 'Hello ' + name + '!'; |
| * }); |
| * |
| * // register a filter factory which uses the |
| * // greet service to demonstrate DI. |
| * $filterProvider.register('greet', function(greet){ |
| * // return the filter function which uses the greet service |
| * // to generate salutation |
| * return function(text) { |
| * // filters need to be forgiving so check input validity |
| * return text && greet(text) || text; |
| * }; |
| * }); |
| * } |
| * ``` |
| * |
| * The filter function is registered with the `$injector` under the filter name suffix with |
| * `Filter`. |
| * |
| * ```js |
| * it('should be the same instance', inject( |
| * function($filterProvider) { |
| * $filterProvider.register('reverse', function(){ |
| * return ...; |
| * }); |
| * }, |
| * function($filter, reverseFilter) { |
| * expect($filter('reverse')).toBe(reverseFilter); |
| * }); |
| * ``` |
| * |
| * |
| * For more information about how angular filters work, and how to create your own filters, see |
| * {@link guide/filter Filters} in the Angular Developer Guide. |
| */ |
| |
| /** |
| * @ngdoc service |
| * @name $filter |
| * @kind function |
| * @description |
| * Filters are used for formatting data displayed to the user. |
| * |
| * The general syntax in templates is as follows: |
| * |
| * {{ expression [| filter_name[:parameter_value] ... ] }} |
| * |
| * @param {String} name Name of the filter function to retrieve |
| * @return {Function} the filter function |
| * @example |
| <example name="$filter" module="filterExample"> |
| <file name="index.html"> |
| <div ng-controller="MainCtrl"> |
| <h3>{{ originalText }}</h3> |
| <h3>{{ filteredText }}</h3> |
| </div> |
| </file> |
| |
| <file name="script.js"> |
| angular.module('filterExample', []) |
| .controller('MainCtrl', function($scope, $filter) { |
| $scope.originalText = 'hello'; |
| $scope.filteredText = $filter('uppercase')($scope.originalText); |
| }); |
| </file> |
| </example> |
| */ |
| $FilterProvider.$inject = ['$provide']; |
| function $FilterProvider($provide) { |
| var suffix = 'Filter'; |
| |
| /** |
| * @ngdoc method |
| * @name $filterProvider#register |
| * @param {string|Object} name Name of the filter function, or an object map of filters where |
| * the keys are the filter names and the values are the filter factories. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`. |
| * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace |
| * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores |
| * (`myapp_subsection_filterx`). |
| * </div> |
| * @param {Function} factory If the first argument was a string, a factory function for the filter to be registered. |
| * @returns {Object} Registered filter instance, or if a map of filters was provided then a map |
| * of the registered filter instances. |
| */ |
| function register(name, factory) { |
| if (isObject(name)) { |
| var filters = {}; |
| forEach(name, function(filter, key) { |
| filters[key] = register(key, filter); |
| }); |
| return filters; |
| } else { |
| return $provide.factory(name + suffix, factory); |
| } |
| } |
| this.register = register; |
| |
| this.$get = ['$injector', function($injector) { |
| return function(name) { |
| return $injector.get(name + suffix); |
| }; |
| }]; |
| |
| //////////////////////////////////////// |
| |
| /* global |
| currencyFilter: false, |
| dateFilter: false, |
| filterFilter: false, |
| jsonFilter: false, |
| limitToFilter: false, |
| lowercaseFilter: false, |
| numberFilter: false, |
| orderByFilter: false, |
| uppercaseFilter: false, |
| */ |
| |
| register('currency', currencyFilter); |
| register('date', dateFilter); |
| register('filter', filterFilter); |
| register('json', jsonFilter); |
| register('limitTo', limitToFilter); |
| register('lowercase', lowercaseFilter); |
| register('number', numberFilter); |
| register('orderBy', orderByFilter); |
| register('uppercase', uppercaseFilter); |
| } |
| |
| /** |
| * @ngdoc filter |
| * @name filter |
| * @kind function |
| * |
| * @description |
| * Selects a subset of items from `array` and returns it as a new array. |
| * |
| * @param {Array} array The source array. |
| * @param {string|Object|function()} expression The predicate to be used for selecting items from |
| * `array`. |
| * |
| * Can be one of: |
| * |
| * - `string`: The string is used for matching against the contents of the `array`. All strings or |
| * objects with string properties in `array` that match this string will be returned. This also |
| * applies to nested object properties. |
| * The predicate can be negated by prefixing the string with `!`. |
| * |
| * - `Object`: A pattern object can be used to filter specific properties on objects contained |
| * by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items |
| * which have property `name` containing "M" and property `phone` containing "1". A special |
| * property name `$` can be used (as in `{$:"text"}`) to accept a match against any |
| * property of the object or its nested object properties. That's equivalent to the simple |
| * substring match with a `string` as described above. The predicate can be negated by prefixing |
| * the string with `!`. |
| * For example `{name: "!M"}` predicate will return an array of items which have property `name` |
| * not containing "M". |
| * |
| * Note that a named property will match properties on the same level only, while the special |
| * `$` property will match properties on the same level or deeper. E.g. an array item like |
| * `{name: {first: 'John', last: 'Doe'}}` will **not** be matched by `{name: 'John'}`, but |
| * **will** be matched by `{$: 'John'}`. |
| * |
| * - `function(value, index, array)`: A predicate function can be used to write arbitrary filters. |
| * The function is called for each element of the array, with the element, its index, and |
| * the entire array itself as arguments. |
| * |
| * The final result is an array of those elements that the predicate returned true for. |
| * |
| * @param {function(actual, expected)|true|undefined} comparator Comparator which is used in |
| * determining if the expected value (from the filter expression) and actual value (from |
| * the object in the array) should be considered a match. |
| * |
| * Can be one of: |
| * |
| * - `function(actual, expected)`: |
| * The function will be given the object value and the predicate value to compare and |
| * should return true if both values should be considered equal. |
| * |
| * - `true`: A shorthand for `function(actual, expected) { return angular.equals(actual, expected)}`. |
| * This is essentially strict comparison of expected and actual. |
| * |
| * - `false|undefined`: A short hand for a function which will look for a substring match in case |
| * insensitive way. |
| * |
| * Primitive values are converted to strings. Objects are not compared against primitives, |
| * unless they have a custom `toString` method (e.g. `Date` objects). |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <div ng-init="friends = [{name:'John', phone:'555-1276'}, |
| {name:'Mary', phone:'800-BIG-MARY'}, |
| {name:'Mike', phone:'555-4321'}, |
| {name:'Adam', phone:'555-5678'}, |
| {name:'Julie', phone:'555-8765'}, |
| {name:'Juliette', phone:'555-5678'}]"></div> |
| |
| <label>Search: <input ng-model="searchText"></label> |
| <table id="searchTextResults"> |
| <tr><th>Name</th><th>Phone</th></tr> |
| <tr ng-repeat="friend in friends | filter:searchText"> |
| <td>{{friend.name}}</td> |
| <td>{{friend.phone}}</td> |
| </tr> |
| </table> |
| <hr> |
| <label>Any: <input ng-model="search.$"></label> <br> |
| <label>Name only <input ng-model="search.name"></label><br> |
| <label>Phone only <input ng-model="search.phone"></label><br> |
| <label>Equality <input type="checkbox" ng-model="strict"></label><br> |
| <table id="searchObjResults"> |
| <tr><th>Name</th><th>Phone</th></tr> |
| <tr ng-repeat="friendObj in friends | filter:search:strict"> |
| <td>{{friendObj.name}}</td> |
| <td>{{friendObj.phone}}</td> |
| </tr> |
| </table> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var expectFriendNames = function(expectedNames, key) { |
| element.all(by.repeater(key + ' in friends').column(key + '.name')).then(function(arr) { |
| arr.forEach(function(wd, i) { |
| expect(wd.getText()).toMatch(expectedNames[i]); |
| }); |
| }); |
| }; |
| |
| it('should search across all fields when filtering with a string', function() { |
| var searchText = element(by.model('searchText')); |
| searchText.clear(); |
| searchText.sendKeys('m'); |
| expectFriendNames(['Mary', 'Mike', 'Adam'], 'friend'); |
| |
| searchText.clear(); |
| searchText.sendKeys('76'); |
| expectFriendNames(['John', 'Julie'], 'friend'); |
| }); |
| |
| it('should search in specific fields when filtering with a predicate object', function() { |
| var searchAny = element(by.model('search.$')); |
| searchAny.clear(); |
| searchAny.sendKeys('i'); |
| expectFriendNames(['Mary', 'Mike', 'Julie', 'Juliette'], 'friendObj'); |
| }); |
| it('should use a equal comparison when comparator is true', function() { |
| var searchName = element(by.model('search.name')); |
| var strict = element(by.model('strict')); |
| searchName.clear(); |
| searchName.sendKeys('Julie'); |
| strict.click(); |
| expectFriendNames(['Julie'], 'friendObj'); |
| }); |
| </file> |
| </example> |
| */ |
| function filterFilter() { |
| return function(array, expression, comparator) { |
| if (!isArrayLike(array)) { |
| if (array == null) { |
| return array; |
| } else { |
| throw minErr('filter')('notarray', 'Expected array but received: {0}', array); |
| } |
| } |
| |
| var expressionType = getTypeForFilter(expression); |
| var predicateFn; |
| var matchAgainstAnyProp; |
| |
| switch (expressionType) { |
| case 'function': |
| predicateFn = expression; |
| break; |
| case 'boolean': |
| case 'null': |
| case 'number': |
| case 'string': |
| matchAgainstAnyProp = true; |
| //jshint -W086 |
| case 'object': |
| //jshint +W086 |
| predicateFn = createPredicateFn(expression, comparator, matchAgainstAnyProp); |
| break; |
| default: |
| return array; |
| } |
| |
| return Array.prototype.filter.call(array, predicateFn); |
| }; |
| } |
| |
| // Helper functions for `filterFilter` |
| function createPredicateFn(expression, comparator, matchAgainstAnyProp) { |
| var shouldMatchPrimitives = isObject(expression) && ('$' in expression); |
| var predicateFn; |
| |
| if (comparator === true) { |
| comparator = equals; |
| } else if (!isFunction(comparator)) { |
| comparator = function(actual, expected) { |
| if (isUndefined(actual)) { |
| // No substring matching against `undefined` |
| return false; |
| } |
| if ((actual === null) || (expected === null)) { |
| // No substring matching against `null`; only match against `null` |
| return actual === expected; |
| } |
| if (isObject(expected) || (isObject(actual) && !hasCustomToString(actual))) { |
| // Should not compare primitives against objects, unless they have custom `toString` method |
| return false; |
| } |
| |
| actual = lowercase('' + actual); |
| expected = lowercase('' + expected); |
| return actual.indexOf(expected) !== -1; |
| }; |
| } |
| |
| predicateFn = function(item) { |
| if (shouldMatchPrimitives && !isObject(item)) { |
| return deepCompare(item, expression.$, comparator, false); |
| } |
| return deepCompare(item, expression, comparator, matchAgainstAnyProp); |
| }; |
| |
| return predicateFn; |
| } |
| |
| function deepCompare(actual, expected, comparator, matchAgainstAnyProp, dontMatchWholeObject) { |
| var actualType = getTypeForFilter(actual); |
| var expectedType = getTypeForFilter(expected); |
| |
| if ((expectedType === 'string') && (expected.charAt(0) === '!')) { |
| return !deepCompare(actual, expected.substring(1), comparator, matchAgainstAnyProp); |
| } else if (isArray(actual)) { |
| // In case `actual` is an array, consider it a match |
| // if ANY of it's items matches `expected` |
| return actual.some(function(item) { |
| return deepCompare(item, expected, comparator, matchAgainstAnyProp); |
| }); |
| } |
| |
| switch (actualType) { |
| case 'object': |
| var key; |
| if (matchAgainstAnyProp) { |
| for (key in actual) { |
| if ((key.charAt(0) !== '$') && deepCompare(actual[key], expected, comparator, true)) { |
| return true; |
| } |
| } |
| return dontMatchWholeObject ? false : deepCompare(actual, expected, comparator, false); |
| } else if (expectedType === 'object') { |
| for (key in expected) { |
| var expectedVal = expected[key]; |
| if (isFunction(expectedVal) || isUndefined(expectedVal)) { |
| continue; |
| } |
| |
| var matchAnyProperty = key === '$'; |
| var actualVal = matchAnyProperty ? actual : actual[key]; |
| if (!deepCompare(actualVal, expectedVal, comparator, matchAnyProperty, matchAnyProperty)) { |
| return false; |
| } |
| } |
| return true; |
| } else { |
| return comparator(actual, expected); |
| } |
| break; |
| case 'function': |
| return false; |
| default: |
| return comparator(actual, expected); |
| } |
| } |
| |
| // Used for easily differentiating between `null` and actual `object` |
| function getTypeForFilter(val) { |
| return (val === null) ? 'null' : typeof val; |
| } |
| |
| /** |
| * @ngdoc filter |
| * @name currency |
| * @kind function |
| * |
| * @description |
| * Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default |
| * symbol for current locale is used. |
| * |
| * @param {number} amount Input to filter. |
| * @param {string=} symbol Currency symbol or identifier to be displayed. |
| * @param {number=} fractionSize Number of decimal places to round the amount to, defaults to default max fraction size for current locale |
| * @returns {string} Formatted number. |
| * |
| * |
| * @example |
| <example module="currencyExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('currencyExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.amount = 1234.56; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <input type="number" ng-model="amount" aria-label="amount"> <br> |
| default currency symbol ($): <span id="currency-default">{{amount | currency}}</span><br> |
| custom currency identifier (USD$): <span id="currency-custom">{{amount | currency:"USD$"}}</span> |
| no fractions (0): <span id="currency-no-fractions">{{amount | currency:"USD$":0}}</span> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should init with 1234.56', function() { |
| expect(element(by.id('currency-default')).getText()).toBe('$1,234.56'); |
| expect(element(by.id('currency-custom')).getText()).toBe('USD$1,234.56'); |
| expect(element(by.id('currency-no-fractions')).getText()).toBe('USD$1,235'); |
| }); |
| it('should update', function() { |
| if (browser.params.browser == 'safari') { |
| // Safari does not understand the minus key. See |
| // https://github.com/angular/protractor/issues/481 |
| return; |
| } |
| element(by.model('amount')).clear(); |
| element(by.model('amount')).sendKeys('-1234'); |
| expect(element(by.id('currency-default')).getText()).toBe('-$1,234.00'); |
| expect(element(by.id('currency-custom')).getText()).toBe('-USD$1,234.00'); |
| expect(element(by.id('currency-no-fractions')).getText()).toBe('-USD$1,234'); |
| }); |
| </file> |
| </example> |
| */ |
| currencyFilter.$inject = ['$locale']; |
| function currencyFilter($locale) { |
| var formats = $locale.NUMBER_FORMATS; |
| return function(amount, currencySymbol, fractionSize) { |
| if (isUndefined(currencySymbol)) { |
| currencySymbol = formats.CURRENCY_SYM; |
| } |
| |
| if (isUndefined(fractionSize)) { |
| fractionSize = formats.PATTERNS[1].maxFrac; |
| } |
| |
| // if null or undefined pass it through |
| return (amount == null) |
| ? amount |
| : formatNumber(amount, formats.PATTERNS[1], formats.GROUP_SEP, formats.DECIMAL_SEP, fractionSize). |
| replace(/\u00A4/g, currencySymbol); |
| }; |
| } |
| |
| /** |
| * @ngdoc filter |
| * @name number |
| * @kind function |
| * |
| * @description |
| * Formats a number as text. |
| * |
| * If the input is null or undefined, it will just be returned. |
| * If the input is infinite (Infinity/-Infinity) the Infinity symbol '∞' is returned. |
| * If the input is not a number an empty string is returned. |
| * |
| * |
| * @param {number|string} number Number to format. |
| * @param {(number|string)=} fractionSize Number of decimal places to round the number to. |
| * If this is not provided then the fraction size is computed from the current locale's number |
| * formatting pattern. In the case of the default locale, it will be 3. |
| * @returns {string} Number rounded to decimalPlaces and places a “,” after each third digit. |
| * |
| * @example |
| <example module="numberFilterExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('numberFilterExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.val = 1234.56789; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <label>Enter number: <input ng-model='val'></label><br> |
| Default formatting: <span id='number-default'>{{val | number}}</span><br> |
| No fractions: <span>{{val | number:0}}</span><br> |
| Negative number: <span>{{-val | number:4}}</span> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should format numbers', function() { |
| expect(element(by.id('number-default')).getText()).toBe('1,234.568'); |
| expect(element(by.binding('val | number:0')).getText()).toBe('1,235'); |
| expect(element(by.binding('-val | number:4')).getText()).toBe('-1,234.5679'); |
| }); |
| |
| it('should update', function() { |
| element(by.model('val')).clear(); |
| element(by.model('val')).sendKeys('3374.333'); |
| expect(element(by.id('number-default')).getText()).toBe('3,374.333'); |
| expect(element(by.binding('val | number:0')).getText()).toBe('3,374'); |
| expect(element(by.binding('-val | number:4')).getText()).toBe('-3,374.3330'); |
| }); |
| </file> |
| </example> |
| */ |
| |
| |
| numberFilter.$inject = ['$locale']; |
| function numberFilter($locale) { |
| var formats = $locale.NUMBER_FORMATS; |
| return function(number, fractionSize) { |
| |
| // if null or undefined pass it through |
| return (number == null) |
| ? number |
| : formatNumber(number, formats.PATTERNS[0], formats.GROUP_SEP, formats.DECIMAL_SEP, |
| fractionSize); |
| }; |
| } |
| |
| var DECIMAL_SEP = '.'; |
| function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) { |
| if (isObject(number)) return ''; |
| |
| var isNegative = number < 0; |
| number = Math.abs(number); |
| |
| var isInfinity = number === Infinity; |
| if (!isInfinity && !isFinite(number)) return ''; |
| |
| var numStr = number + '', |
| formatedText = '', |
| hasExponent = false, |
| parts = []; |
| |
| if (isInfinity) formatedText = '\u221e'; |
| |
| if (!isInfinity && numStr.indexOf('e') !== -1) { |
| var match = numStr.match(/([\d\.]+)e(-?)(\d+)/); |
| if (match && match[2] == '-' && match[3] > fractionSize + 1) { |
| number = 0; |
| } else { |
| formatedText = numStr; |
| hasExponent = true; |
| } |
| } |
| |
| if (!isInfinity && !hasExponent) { |
| var fractionLen = (numStr.split(DECIMAL_SEP)[1] || '').length; |
| |
| // determine fractionSize if it is not specified |
| if (isUndefined(fractionSize)) { |
| fractionSize = Math.min(Math.max(pattern.minFrac, fractionLen), pattern.maxFrac); |
| } |
| |
| // safely round numbers in JS without hitting imprecisions of floating-point arithmetics |
| // inspired by: |
| // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round |
| number = +(Math.round(+(number.toString() + 'e' + fractionSize)).toString() + 'e' + -fractionSize); |
| |
| var fraction = ('' + number).split(DECIMAL_SEP); |
| var whole = fraction[0]; |
| fraction = fraction[1] || ''; |
| |
| var i, pos = 0, |
| lgroup = pattern.lgSize, |
| group = pattern.gSize; |
| |
| if (whole.length >= (lgroup + group)) { |
| pos = whole.length - lgroup; |
| for (i = 0; i < pos; i++) { |
| if ((pos - i) % group === 0 && i !== 0) { |
| formatedText += groupSep; |
| } |
| formatedText += whole.charAt(i); |
| } |
| } |
| |
| for (i = pos; i < whole.length; i++) { |
| if ((whole.length - i) % lgroup === 0 && i !== 0) { |
| formatedText += groupSep; |
| } |
| formatedText += whole.charAt(i); |
| } |
| |
| // format fraction part. |
| while (fraction.length < fractionSize) { |
| fraction += '0'; |
| } |
| |
| if (fractionSize && fractionSize !== "0") formatedText += decimalSep + fraction.substr(0, fractionSize); |
| } else { |
| if (fractionSize > 0 && number < 1) { |
| formatedText = number.toFixed(fractionSize); |
| number = parseFloat(formatedText); |
| formatedText = formatedText.replace(DECIMAL_SEP, decimalSep); |
| } |
| } |
| |
| if (number === 0) { |
| isNegative = false; |
| } |
| |
| parts.push(isNegative ? pattern.negPre : pattern.posPre, |
| formatedText, |
| isNegative ? pattern.negSuf : pattern.posSuf); |
| return parts.join(''); |
| } |
| |
| function padNumber(num, digits, trim) { |
| var neg = ''; |
| if (num < 0) { |
| neg = '-'; |
| num = -num; |
| } |
| num = '' + num; |
| while (num.length < digits) num = '0' + num; |
| if (trim) { |
| num = num.substr(num.length - digits); |
| } |
| return neg + num; |
| } |
| |
| |
| function dateGetter(name, size, offset, trim) { |
| offset = offset || 0; |
| return function(date) { |
| var value = date['get' + name](); |
| if (offset > 0 || value > -offset) { |
| value += offset; |
| } |
| if (value === 0 && offset == -12) value = 12; |
| return padNumber(value, size, trim); |
| }; |
| } |
| |
| function dateStrGetter(name, shortForm) { |
| return function(date, formats) { |
| var value = date['get' + name](); |
| var get = uppercase(shortForm ? ('SHORT' + name) : name); |
| |
| return formats[get][value]; |
| }; |
| } |
| |
| function timeZoneGetter(date, formats, offset) { |
| var zone = -1 * offset; |
| var paddedZone = (zone >= 0) ? "+" : ""; |
| |
| paddedZone += padNumber(Math[zone > 0 ? 'floor' : 'ceil'](zone / 60), 2) + |
| padNumber(Math.abs(zone % 60), 2); |
| |
| return paddedZone; |
| } |
| |
| function getFirstThursdayOfYear(year) { |
| // 0 = index of January |
| var dayOfWeekOnFirst = (new Date(year, 0, 1)).getDay(); |
| // 4 = index of Thursday (+1 to account for 1st = 5) |
| // 11 = index of *next* Thursday (+1 account for 1st = 12) |
| return new Date(year, 0, ((dayOfWeekOnFirst <= 4) ? 5 : 12) - dayOfWeekOnFirst); |
| } |
| |
| function getThursdayThisWeek(datetime) { |
| return new Date(datetime.getFullYear(), datetime.getMonth(), |
| // 4 = index of Thursday |
| datetime.getDate() + (4 - datetime.getDay())); |
| } |
| |
| function weekGetter(size) { |
| return function(date) { |
| var firstThurs = getFirstThursdayOfYear(date.getFullYear()), |
| thisThurs = getThursdayThisWeek(date); |
| |
| var diff = +thisThurs - +firstThurs, |
| result = 1 + Math.round(diff / 6.048e8); // 6.048e8 ms per week |
| |
| return padNumber(result, size); |
| }; |
| } |
| |
| function ampmGetter(date, formats) { |
| return date.getHours() < 12 ? formats.AMPMS[0] : formats.AMPMS[1]; |
| } |
| |
| function eraGetter(date, formats) { |
| return date.getFullYear() <= 0 ? formats.ERAS[0] : formats.ERAS[1]; |
| } |
| |
| function longEraGetter(date, formats) { |
| return date.getFullYear() <= 0 ? formats.ERANAMES[0] : formats.ERANAMES[1]; |
| } |
| |
| var DATE_FORMATS = { |
| yyyy: dateGetter('FullYear', 4), |
| yy: dateGetter('FullYear', 2, 0, true), |
| y: dateGetter('FullYear', 1), |
| MMMM: dateStrGetter('Month'), |
| MMM: dateStrGetter('Month', true), |
| MM: dateGetter('Month', 2, 1), |
| M: dateGetter('Month', 1, 1), |
| dd: dateGetter('Date', 2), |
| d: dateGetter('Date', 1), |
| HH: dateGetter('Hours', 2), |
| H: dateGetter('Hours', 1), |
| hh: dateGetter('Hours', 2, -12), |
| h: dateGetter('Hours', 1, -12), |
| mm: dateGetter('Minutes', 2), |
| m: dateGetter('Minutes', 1), |
| ss: dateGetter('Seconds', 2), |
| s: dateGetter('Seconds', 1), |
| // while ISO 8601 requires fractions to be prefixed with `.` or `,` |
| // we can be just safely rely on using `sss` since we currently don't support single or two digit fractions |
| sss: dateGetter('Milliseconds', 3), |
| EEEE: dateStrGetter('Day'), |
| EEE: dateStrGetter('Day', true), |
| a: ampmGetter, |
| Z: timeZoneGetter, |
| ww: weekGetter(2), |
| w: weekGetter(1), |
| G: eraGetter, |
| GG: eraGetter, |
| GGG: eraGetter, |
| GGGG: longEraGetter |
| }; |
| |
| var DATE_FORMATS_SPLIT = /((?:[^yMdHhmsaZEwG']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|d+|H+|h+|m+|s+|a|Z|G+|w+))(.*)/, |
| NUMBER_STRING = /^\-?\d+$/; |
| |
| /** |
| * @ngdoc filter |
| * @name date |
| * @kind function |
| * |
| * @description |
| * Formats `date` to a string based on the requested `format`. |
| * |
| * `format` string can be composed of the following elements: |
| * |
| * * `'yyyy'`: 4 digit representation of year (e.g. AD 1 => 0001, AD 2010 => 2010) |
| * * `'yy'`: 2 digit representation of year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10) |
| * * `'y'`: 1 digit representation of year, e.g. (AD 1 => 1, AD 199 => 199) |
| * * `'MMMM'`: Month in year (January-December) |
| * * `'MMM'`: Month in year (Jan-Dec) |
| * * `'MM'`: Month in year, padded (01-12) |
| * * `'M'`: Month in year (1-12) |
| * * `'dd'`: Day in month, padded (01-31) |
| * * `'d'`: Day in month (1-31) |
| * * `'EEEE'`: Day in Week,(Sunday-Saturday) |
| * * `'EEE'`: Day in Week, (Sun-Sat) |
| * * `'HH'`: Hour in day, padded (00-23) |
| * * `'H'`: Hour in day (0-23) |
| * * `'hh'`: Hour in AM/PM, padded (01-12) |
| * * `'h'`: Hour in AM/PM, (1-12) |
| * * `'mm'`: Minute in hour, padded (00-59) |
| * * `'m'`: Minute in hour (0-59) |
| * * `'ss'`: Second in minute, padded (00-59) |
| * * `'s'`: Second in minute (0-59) |
| * * `'sss'`: Millisecond in second, padded (000-999) |
| * * `'a'`: AM/PM marker |
| * * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-+1200) |
| * * `'ww'`: Week of year, padded (00-53). Week 01 is the week with the first Thursday of the year |
| * * `'w'`: Week of year (0-53). Week 1 is the week with the first Thursday of the year |
| * * `'G'`, `'GG'`, `'GGG'`: The abbreviated form of the era string (e.g. 'AD') |
| * * `'GGGG'`: The long form of the era string (e.g. 'Anno Domini') |
| * |
| * `format` string can also be one of the following predefined |
| * {@link guide/i18n localizable formats}: |
| * |
| * * `'medium'`: equivalent to `'MMM d, y h:mm:ss a'` for en_US locale |
| * (e.g. Sep 3, 2010 12:05:08 PM) |
| * * `'short'`: equivalent to `'M/d/yy h:mm a'` for en_US locale (e.g. 9/3/10 12:05 PM) |
| * * `'fullDate'`: equivalent to `'EEEE, MMMM d, y'` for en_US locale |
| * (e.g. Friday, September 3, 2010) |
| * * `'longDate'`: equivalent to `'MMMM d, y'` for en_US locale (e.g. September 3, 2010) |
| * * `'mediumDate'`: equivalent to `'MMM d, y'` for en_US locale (e.g. Sep 3, 2010) |
| * * `'shortDate'`: equivalent to `'M/d/yy'` for en_US locale (e.g. 9/3/10) |
| * * `'mediumTime'`: equivalent to `'h:mm:ss a'` for en_US locale (e.g. 12:05:08 PM) |
| * * `'shortTime'`: equivalent to `'h:mm a'` for en_US locale (e.g. 12:05 PM) |
| * |
| * `format` string can contain literal values. These need to be escaped by surrounding with single quotes (e.g. |
| * `"h 'in the morning'"`). In order to output a single quote, escape it - i.e., two single quotes in a sequence |
| * (e.g. `"h 'o''clock'"`). |
| * |
| * @param {(Date|number|string)} date Date to format either as Date object, milliseconds (string or |
| * number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.sssZ and its |
| * shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is |
| * specified in the string input, the time is considered to be in the local timezone. |
| * @param {string=} format Formatting rules (see Description). If not specified, |
| * `mediumDate` is used. |
| * @param {string=} timezone Timezone to be used for formatting. It understands UTC/GMT and the |
| * continental US time zone abbreviations, but for general use, use a time zone offset, for |
| * example, `'+0430'` (4 hours, 30 minutes east of the Greenwich meridian) |
| * If not specified, the timezone of the browser will be used. |
| * @returns {string} Formatted string or the input if input is not recognized as date/millis. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <span ng-non-bindable>{{1288323623006 | date:'medium'}}</span>: |
| <span>{{1288323623006 | date:'medium'}}</span><br> |
| <span ng-non-bindable>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span>: |
| <span>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span><br> |
| <span ng-non-bindable>{{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}</span>: |
| <span>{{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}</span><br> |
| <span ng-non-bindable>{{1288323623006 | date:"MM/dd/yyyy 'at' h:mma"}}</span>: |
| <span>{{'1288323623006' | date:"MM/dd/yyyy 'at' h:mma"}}</span><br> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should format date', function() { |
| expect(element(by.binding("1288323623006 | date:'medium'")).getText()). |
| toMatch(/Oct 2\d, 2010 \d{1,2}:\d{2}:\d{2} (AM|PM)/); |
| expect(element(by.binding("1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'")).getText()). |
| toMatch(/2010\-10\-2\d \d{2}:\d{2}:\d{2} (\-|\+)?\d{4}/); |
| expect(element(by.binding("'1288323623006' | date:'MM/dd/yyyy @ h:mma'")).getText()). |
| toMatch(/10\/2\d\/2010 @ \d{1,2}:\d{2}(AM|PM)/); |
| expect(element(by.binding("'1288323623006' | date:\"MM/dd/yyyy 'at' h:mma\"")).getText()). |
| toMatch(/10\/2\d\/2010 at \d{1,2}:\d{2}(AM|PM)/); |
| }); |
| </file> |
| </example> |
| */ |
| dateFilter.$inject = ['$locale']; |
| function dateFilter($locale) { |
| |
| |
| var R_ISO8601_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/; |
| // 1 2 3 4 5 6 7 8 9 10 11 |
| function jsonStringToDate(string) { |
| var match; |
| if (match = string.match(R_ISO8601_STR)) { |
| var date = new Date(0), |
| tzHour = 0, |
| tzMin = 0, |
| dateSetter = match[8] ? date.setUTCFullYear : date.setFullYear, |
| timeSetter = match[8] ? date.setUTCHours : date.setHours; |
| |
| if (match[9]) { |
| tzHour = toInt(match[9] + match[10]); |
| tzMin = toInt(match[9] + match[11]); |
| } |
| dateSetter.call(date, toInt(match[1]), toInt(match[2]) - 1, toInt(match[3])); |
| var h = toInt(match[4] || 0) - tzHour; |
| var m = toInt(match[5] || 0) - tzMin; |
| var s = toInt(match[6] || 0); |
| var ms = Math.round(parseFloat('0.' + (match[7] || 0)) * 1000); |
| timeSetter.call(date, h, m, s, ms); |
| return date; |
| } |
| return string; |
| } |
| |
| |
| return function(date, format, timezone) { |
| var text = '', |
| parts = [], |
| fn, match; |
| |
| format = format || 'mediumDate'; |
| format = $locale.DATETIME_FORMATS[format] || format; |
| if (isString(date)) { |
| date = NUMBER_STRING.test(date) ? toInt(date) : jsonStringToDate(date); |
| } |
| |
| if (isNumber(date)) { |
| date = new Date(date); |
| } |
| |
| if (!isDate(date) || !isFinite(date.getTime())) { |
| return date; |
| } |
| |
| while (format) { |
| match = DATE_FORMATS_SPLIT.exec(format); |
| if (match) { |
| parts = concat(parts, match, 1); |
| format = parts.pop(); |
| } else { |
| parts.push(format); |
| format = null; |
| } |
| } |
| |
| var dateTimezoneOffset = date.getTimezoneOffset(); |
| if (timezone) { |
| dateTimezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset()); |
| date = convertTimezoneToLocal(date, timezone, true); |
| } |
| forEach(parts, function(value) { |
| fn = DATE_FORMATS[value]; |
| text += fn ? fn(date, $locale.DATETIME_FORMATS, dateTimezoneOffset) |
| : value.replace(/(^'|'$)/g, '').replace(/''/g, "'"); |
| }); |
| |
| return text; |
| }; |
| } |
| |
| |
| /** |
| * @ngdoc filter |
| * @name json |
| * @kind function |
| * |
| * @description |
| * Allows you to convert a JavaScript object into JSON string. |
| * |
| * This filter is mostly useful for debugging. When using the double curly {{value}} notation |
| * the binding is automatically converted to JSON. |
| * |
| * @param {*} object Any JavaScript object (including arrays and primitive types) to filter. |
| * @param {number=} spacing The number of spaces to use per indentation, defaults to 2. |
| * @returns {string} JSON string. |
| * |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <pre id="default-spacing">{{ {'name':'value'} | json }}</pre> |
| <pre id="custom-spacing">{{ {'name':'value'} | json:4 }}</pre> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should jsonify filtered objects', function() { |
| expect(element(by.id('default-spacing')).getText()).toMatch(/\{\n "name": ?"value"\n}/); |
| expect(element(by.id('custom-spacing')).getText()).toMatch(/\{\n "name": ?"value"\n}/); |
| }); |
| </file> |
| </example> |
| * |
| */ |
| function jsonFilter() { |
| return function(object, spacing) { |
| if (isUndefined(spacing)) { |
| spacing = 2; |
| } |
| return toJson(object, spacing); |
| }; |
| } |
| |
| |
| /** |
| * @ngdoc filter |
| * @name lowercase |
| * @kind function |
| * @description |
| * Converts string to lowercase. |
| * @see angular.lowercase |
| */ |
| var lowercaseFilter = valueFn(lowercase); |
| |
| |
| /** |
| * @ngdoc filter |
| * @name uppercase |
| * @kind function |
| * @description |
| * Converts string to uppercase. |
| * @see angular.uppercase |
| */ |
| var uppercaseFilter = valueFn(uppercase); |
| |
| /** |
| * @ngdoc filter |
| * @name limitTo |
| * @kind function |
| * |
| * @description |
| * Creates a new array or string containing only a specified number of elements. The elements |
| * are taken from either the beginning or the end of the source array, string or number, as specified by |
| * the value and sign (positive or negative) of `limit`. If a number is used as input, it is |
| * converted to a string. |
| * |
| * @param {Array|string|number} input Source array, string or number to be limited. |
| * @param {string|number} limit The length of the returned array or string. If the `limit` number |
| * is positive, `limit` number of items from the beginning of the source array/string are copied. |
| * If the number is negative, `limit` number of items from the end of the source array/string |
| * are copied. The `limit` will be trimmed if it exceeds `array.length`. If `limit` is undefined, |
| * the input will be returned unchanged. |
| * @param {(string|number)=} begin Index at which to begin limitation. As a negative index, `begin` |
| * indicates an offset from the end of `input`. Defaults to `0`. |
| * @returns {Array|string} A new sub-array or substring of length `limit` or less if input array |
| * had less than `limit` elements. |
| * |
| * @example |
| <example module="limitToExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('limitToExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.numbers = [1,2,3,4,5,6,7,8,9]; |
| $scope.letters = "abcdefghi"; |
| $scope.longNumber = 2345432342; |
| $scope.numLimit = 3; |
| $scope.letterLimit = 3; |
| $scope.longNumberLimit = 3; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <label> |
| Limit {{numbers}} to: |
| <input type="number" step="1" ng-model="numLimit"> |
| </label> |
| <p>Output numbers: {{ numbers | limitTo:numLimit }}</p> |
| <label> |
| Limit {{letters}} to: |
| <input type="number" step="1" ng-model="letterLimit"> |
| </label> |
| <p>Output letters: {{ letters | limitTo:letterLimit }}</p> |
| <label> |
| Limit {{longNumber}} to: |
| <input type="number" step="1" ng-model="longNumberLimit"> |
| </label> |
| <p>Output long number: {{ longNumber | limitTo:longNumberLimit }}</p> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var numLimitInput = element(by.model('numLimit')); |
| var letterLimitInput = element(by.model('letterLimit')); |
| var longNumberLimitInput = element(by.model('longNumberLimit')); |
| var limitedNumbers = element(by.binding('numbers | limitTo:numLimit')); |
| var limitedLetters = element(by.binding('letters | limitTo:letterLimit')); |
| var limitedLongNumber = element(by.binding('longNumber | limitTo:longNumberLimit')); |
| |
| it('should limit the number array to first three items', function() { |
| expect(numLimitInput.getAttribute('value')).toBe('3'); |
| expect(letterLimitInput.getAttribute('value')).toBe('3'); |
| expect(longNumberLimitInput.getAttribute('value')).toBe('3'); |
| expect(limitedNumbers.getText()).toEqual('Output numbers: [1,2,3]'); |
| expect(limitedLetters.getText()).toEqual('Output letters: abc'); |
| expect(limitedLongNumber.getText()).toEqual('Output long number: 234'); |
| }); |
| |
| // There is a bug in safari and protractor that doesn't like the minus key |
| // it('should update the output when -3 is entered', function() { |
| // numLimitInput.clear(); |
| // numLimitInput.sendKeys('-3'); |
| // letterLimitInput.clear(); |
| // letterLimitInput.sendKeys('-3'); |
| // longNumberLimitInput.clear(); |
| // longNumberLimitInput.sendKeys('-3'); |
| // expect(limitedNumbers.getText()).toEqual('Output numbers: [7,8,9]'); |
| // expect(limitedLetters.getText()).toEqual('Output letters: ghi'); |
| // expect(limitedLongNumber.getText()).toEqual('Output long number: 342'); |
| // }); |
| |
| it('should not exceed the maximum size of input array', function() { |
| numLimitInput.clear(); |
| numLimitInput.sendKeys('100'); |
| letterLimitInput.clear(); |
| letterLimitInput.sendKeys('100'); |
| longNumberLimitInput.clear(); |
| longNumberLimitInput.sendKeys('100'); |
| expect(limitedNumbers.getText()).toEqual('Output numbers: [1,2,3,4,5,6,7,8,9]'); |
| expect(limitedLetters.getText()).toEqual('Output letters: abcdefghi'); |
| expect(limitedLongNumber.getText()).toEqual('Output long number: 2345432342'); |
| }); |
| </file> |
| </example> |
| */ |
| function limitToFilter() { |
| return function(input, limit, begin) { |
| if (Math.abs(Number(limit)) === Infinity) { |
| limit = Number(limit); |
| } else { |
| limit = toInt(limit); |
| } |
| if (isNaN(limit)) return input; |
| |
| if (isNumber(input)) input = input.toString(); |
| if (!isArray(input) && !isString(input)) return input; |
| |
| begin = (!begin || isNaN(begin)) ? 0 : toInt(begin); |
| begin = (begin < 0 && begin >= -input.length) ? input.length + begin : begin; |
| |
| if (limit >= 0) { |
| return input.slice(begin, begin + limit); |
| } else { |
| if (begin === 0) { |
| return input.slice(limit, input.length); |
| } else { |
| return input.slice(Math.max(0, begin + limit), begin); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * @ngdoc filter |
| * @name orderBy |
| * @kind function |
| * |
| * @description |
| * Orders a specified `array` by the `expression` predicate. It is ordered alphabetically |
| * for strings and numerically for numbers. Note: if you notice numbers are not being sorted |
| * as expected, make sure they are actually being saved as numbers and not strings. |
| * |
| * @param {Array} array The array to sort. |
| * @param {function(*)|string|Array.<(function(*)|string)>=} expression A predicate to be |
| * used by the comparator to determine the order of elements. |
| * |
| * Can be one of: |
| * |
| * - `function`: Getter function. The result of this function will be sorted using the |
| * `<`, `===`, `>` operator. |
| * - `string`: An Angular expression. The result of this expression is used to compare elements |
| * (for example `name` to sort by a property called `name` or `name.substr(0, 3)` to sort by |
| * 3 first characters of a property called `name`). The result of a constant expression |
| * is interpreted as a property name to be used in comparisons (for example `"special name"` |
| * to sort object by the value of their `special name` property). An expression can be |
| * optionally prefixed with `+` or `-` to control ascending or descending sort order |
| * (for example, `+name` or `-name`). If no property is provided, (e.g. `'+'`) then the array |
| * element itself is used to compare where sorting. |
| * - `Array`: An array of function or string predicates. The first predicate in the array |
| * is used for sorting, but when two items are equivalent, the next predicate is used. |
| * |
| * If the predicate is missing or empty then it defaults to `'+'`. |
| * |
| * @param {boolean=} reverse Reverse the order of the array. |
| * @returns {Array} Sorted copy of the source array. |
| * |
| * |
| * @example |
| * The example below demonstrates a simple ngRepeat, where the data is sorted |
| * by age in descending order (predicate is set to `'-age'`). |
| * `reverse` is not set, which means it defaults to `false`. |
| <example module="orderByExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('orderByExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.friends = |
| [{name:'John', phone:'555-1212', age:10}, |
| {name:'Mary', phone:'555-9876', age:19}, |
| {name:'Mike', phone:'555-4321', age:21}, |
| {name:'Adam', phone:'555-5678', age:35}, |
| {name:'Julie', phone:'555-8765', age:29}]; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <table class="friend"> |
| <tr> |
| <th>Name</th> |
| <th>Phone Number</th> |
| <th>Age</th> |
| </tr> |
| <tr ng-repeat="friend in friends | orderBy:'-age'"> |
| <td>{{friend.name}}</td> |
| <td>{{friend.phone}}</td> |
| <td>{{friend.age}}</td> |
| </tr> |
| </table> |
| </div> |
| </file> |
| </example> |
| * |
| * The predicate and reverse parameters can be controlled dynamically through scope properties, |
| * as shown in the next example. |
| * @example |
| <example module="orderByExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('orderByExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.friends = |
| [{name:'John', phone:'555-1212', age:10}, |
| {name:'Mary', phone:'555-9876', age:19}, |
| {name:'Mike', phone:'555-4321', age:21}, |
| {name:'Adam', phone:'555-5678', age:35}, |
| {name:'Julie', phone:'555-8765', age:29}]; |
| $scope.predicate = 'age'; |
| $scope.reverse = true; |
| $scope.order = function(predicate) { |
| $scope.reverse = ($scope.predicate === predicate) ? !$scope.reverse : false; |
| $scope.predicate = predicate; |
| }; |
| }]); |
| </script> |
| <style type="text/css"> |
| .sortorder:after { |
| content: '\25b2'; |
| } |
| .sortorder.reverse:after { |
| content: '\25bc'; |
| } |
| </style> |
| <div ng-controller="ExampleController"> |
| <pre>Sorting predicate = {{predicate}}; reverse = {{reverse}}</pre> |
| <hr/> |
| [ <a href="" ng-click="predicate=''">unsorted</a> ] |
| <table class="friend"> |
| <tr> |
| <th> |
| <a href="" ng-click="order('name')">Name</a> |
| <span class="sortorder" ng-show="predicate === 'name'" ng-class="{reverse:reverse}"></span> |
| </th> |
| <th> |
| <a href="" ng-click="order('phone')">Phone Number</a> |
| <span class="sortorder" ng-show="predicate === 'phone'" ng-class="{reverse:reverse}"></span> |
| </th> |
| <th> |
| <a href="" ng-click="order('age')">Age</a> |
| <span class="sortorder" ng-show="predicate === 'age'" ng-class="{reverse:reverse}"></span> |
| </th> |
| </tr> |
| <tr ng-repeat="friend in friends | orderBy:predicate:reverse"> |
| <td>{{friend.name}}</td> |
| <td>{{friend.phone}}</td> |
| <td>{{friend.age}}</td> |
| </tr> |
| </table> |
| </div> |
| </file> |
| </example> |
| * |
| * It's also possible to call the orderBy filter manually, by injecting `$filter`, retrieving the |
| * filter routine with `$filter('orderBy')`, and calling the returned filter routine with the |
| * desired parameters. |
| * |
| * Example: |
| * |
| * @example |
| <example module="orderByExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <table class="friend"> |
| <tr> |
| <th><a href="" ng-click="reverse=false;order('name', false)">Name</a> |
| (<a href="" ng-click="order('-name',false)">^</a>)</th> |
| <th><a href="" ng-click="reverse=!reverse;order('phone', reverse)">Phone Number</a></th> |
| <th><a href="" ng-click="reverse=!reverse;order('age',reverse)">Age</a></th> |
| </tr> |
| <tr ng-repeat="friend in friends"> |
| <td>{{friend.name}}</td> |
| <td>{{friend.phone}}</td> |
| <td>{{friend.age}}</td> |
| </tr> |
| </table> |
| </div> |
| </file> |
| |
| <file name="script.js"> |
| angular.module('orderByExample', []) |
| .controller('ExampleController', ['$scope', '$filter', function($scope, $filter) { |
| var orderBy = $filter('orderBy'); |
| $scope.friends = [ |
| { name: 'John', phone: '555-1212', age: 10 }, |
| { name: 'Mary', phone: '555-9876', age: 19 }, |
| { name: 'Mike', phone: '555-4321', age: 21 }, |
| { name: 'Adam', phone: '555-5678', age: 35 }, |
| { name: 'Julie', phone: '555-8765', age: 29 } |
| ]; |
| $scope.order = function(predicate, reverse) { |
| $scope.friends = orderBy($scope.friends, predicate, reverse); |
| }; |
| $scope.order('-age',false); |
| }]); |
| </file> |
| </example> |
| */ |
| orderByFilter.$inject = ['$parse']; |
| function orderByFilter($parse) { |
| return function(array, sortPredicate, reverseOrder) { |
| |
| if (!(isArrayLike(array))) return array; |
| |
| if (!isArray(sortPredicate)) { sortPredicate = [sortPredicate]; } |
| if (sortPredicate.length === 0) { sortPredicate = ['+']; } |
| |
| var predicates = processPredicates(sortPredicate, reverseOrder); |
| // Add a predicate at the end that evaluates to the element index. This makes the |
| // sort stable as it works as a tie-breaker when all the input predicates cannot |
| // distinguish between two elements. |
| predicates.push({ get: function() { return {}; }, descending: reverseOrder ? -1 : 1}); |
| |
| // The next three lines are a version of a Swartzian Transform idiom from Perl |
| // (sometimes called the Decorate-Sort-Undecorate idiom) |
| // See https://en.wikipedia.org/wiki/Schwartzian_transform |
| var compareValues = Array.prototype.map.call(array, getComparisonObject); |
| compareValues.sort(doComparison); |
| array = compareValues.map(function(item) { return item.value; }); |
| |
| return array; |
| |
| function getComparisonObject(value, index) { |
| return { |
| value: value, |
| predicateValues: predicates.map(function(predicate) { |
| return getPredicateValue(predicate.get(value), index); |
| }) |
| }; |
| } |
| |
| function doComparison(v1, v2) { |
| var result = 0; |
| for (var index=0, length = predicates.length; index < length; ++index) { |
| result = compare(v1.predicateValues[index], v2.predicateValues[index]) * predicates[index].descending; |
| if (result) break; |
| } |
| return result; |
| } |
| }; |
| |
| function processPredicates(sortPredicate, reverseOrder) { |
| reverseOrder = reverseOrder ? -1 : 1; |
| return sortPredicate.map(function(predicate) { |
| var descending = 1, get = identity; |
| |
| if (isFunction(predicate)) { |
| get = predicate; |
| } else if (isString(predicate)) { |
| if ((predicate.charAt(0) == '+' || predicate.charAt(0) == '-')) { |
| descending = predicate.charAt(0) == '-' ? -1 : 1; |
| predicate = predicate.substring(1); |
| } |
| if (predicate !== '') { |
| get = $parse(predicate); |
| if (get.constant) { |
| var key = get(); |
| get = function(value) { return value[key]; }; |
| } |
| } |
| } |
| return { get: get, descending: descending * reverseOrder }; |
| }); |
| } |
| |
| function isPrimitive(value) { |
| switch (typeof value) { |
| case 'number': /* falls through */ |
| case 'boolean': /* falls through */ |
| case 'string': |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| function objectValue(value, index) { |
| // If `valueOf` is a valid function use that |
| if (typeof value.valueOf === 'function') { |
| value = value.valueOf(); |
| if (isPrimitive(value)) return value; |
| } |
| // If `toString` is a valid function and not the one from `Object.prototype` use that |
| if (hasCustomToString(value)) { |
| value = value.toString(); |
| if (isPrimitive(value)) return value; |
| } |
| // We have a basic object so we use the position of the object in the collection |
| return index; |
| } |
| |
| function getPredicateValue(value, index) { |
| var type = typeof value; |
| if (value === null) { |
| type = 'string'; |
| value = 'null'; |
| } else if (type === 'string') { |
| value = value.toLowerCase(); |
| } else if (type === 'object') { |
| value = objectValue(value, index); |
| } |
| return { value: value, type: type }; |
| } |
| |
| function compare(v1, v2) { |
| var result = 0; |
| if (v1.type === v2.type) { |
| if (v1.value !== v2.value) { |
| result = v1.value < v2.value ? -1 : 1; |
| } |
| } else { |
| result = v1.type < v2.type ? -1 : 1; |
| } |
| return result; |
| } |
| } |
| |
| function ngDirective(directive) { |
| if (isFunction(directive)) { |
| directive = { |
| link: directive |
| }; |
| } |
| directive.restrict = directive.restrict || 'AC'; |
| return valueFn(directive); |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name a |
| * @restrict E |
| * |
| * @description |
| * Modifies the default behavior of the html A tag so that the default action is prevented when |
| * the href attribute is empty. |
| * |
| * This change permits the easy creation of action links with the `ngClick` directive |
| * without changing the location or causing page reloads, e.g.: |
| * `<a href="" ng-click="list.addItem()">Add Item</a>` |
| */ |
| var htmlAnchorDirective = valueFn({ |
| restrict: 'E', |
| compile: function(element, attr) { |
| if (!attr.href && !attr.xlinkHref) { |
| return function(scope, element) { |
| // If the linked element is not an anchor tag anymore, do nothing |
| if (element[0].nodeName.toLowerCase() !== 'a') return; |
| |
| // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute. |
| var href = toString.call(element.prop('href')) === '[object SVGAnimatedString]' ? |
| 'xlink:href' : 'href'; |
| element.on('click', function(event) { |
| // if we have no href url, then don't navigate anywhere. |
| if (!element.attr(href)) { |
| event.preventDefault(); |
| } |
| }); |
| }; |
| } |
| } |
| }); |
| |
| /** |
| * @ngdoc directive |
| * @name ngHref |
| * @restrict A |
| * @priority 99 |
| * |
| * @description |
| * Using Angular markup like `{{hash}}` in an href attribute will |
| * make the link go to the wrong URL if the user clicks it before |
| * Angular has a chance to replace the `{{hash}}` markup with its |
| * value. Until Angular replaces the markup the link will be broken |
| * and will most likely return a 404 error. The `ngHref` directive |
| * solves this problem. |
| * |
| * The wrong way to write it: |
| * ```html |
| * <a href="http://www.gravatar.com/avatar/{{hash}}">link1</a> |
| * ``` |
| * |
| * The correct way to write it: |
| * ```html |
| * <a ng-href="http://www.gravatar.com/avatar/{{hash}}">link1</a> |
| * ``` |
| * |
| * @element A |
| * @param {template} ngHref any string which can contain `{{}}` markup. |
| * |
| * @example |
| * This example shows various combinations of `href`, `ng-href` and `ng-click` attributes |
| * in links and their different behaviors: |
| <example> |
| <file name="index.html"> |
| <input ng-model="value" /><br /> |
| <a id="link-1" href ng-click="value = 1">link 1</a> (link, don't reload)<br /> |
| <a id="link-2" href="" ng-click="value = 2">link 2</a> (link, don't reload)<br /> |
| <a id="link-3" ng-href="/{{'123'}}">link 3</a> (link, reload!)<br /> |
| <a id="link-4" href="" name="xx" ng-click="value = 4">anchor</a> (link, don't reload)<br /> |
| <a id="link-5" name="xxx" ng-click="value = 5">anchor</a> (no link)<br /> |
| <a id="link-6" ng-href="{{value}}">link</a> (link, change location) |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should execute ng-click but not reload when href without value', function() { |
| element(by.id('link-1')).click(); |
| expect(element(by.model('value')).getAttribute('value')).toEqual('1'); |
| expect(element(by.id('link-1')).getAttribute('href')).toBe(''); |
| }); |
| |
| it('should execute ng-click but not reload when href empty string', function() { |
| element(by.id('link-2')).click(); |
| expect(element(by.model('value')).getAttribute('value')).toEqual('2'); |
| expect(element(by.id('link-2')).getAttribute('href')).toBe(''); |
| }); |
| |
| it('should execute ng-click and change url when ng-href specified', function() { |
| expect(element(by.id('link-3')).getAttribute('href')).toMatch(/\/123$/); |
| |
| element(by.id('link-3')).click(); |
| |
| // At this point, we navigate away from an Angular page, so we need |
| // to use browser.driver to get the base webdriver. |
| |
| browser.wait(function() { |
| return browser.driver.getCurrentUrl().then(function(url) { |
| return url.match(/\/123$/); |
| }); |
| }, 5000, 'page should navigate to /123'); |
| }); |
| |
| it('should execute ng-click but not reload when href empty string and name specified', function() { |
| element(by.id('link-4')).click(); |
| expect(element(by.model('value')).getAttribute('value')).toEqual('4'); |
| expect(element(by.id('link-4')).getAttribute('href')).toBe(''); |
| }); |
| |
| it('should execute ng-click but not reload when no href but name specified', function() { |
| element(by.id('link-5')).click(); |
| expect(element(by.model('value')).getAttribute('value')).toEqual('5'); |
| expect(element(by.id('link-5')).getAttribute('href')).toBe(null); |
| }); |
| |
| it('should only change url when only ng-href', function() { |
| element(by.model('value')).clear(); |
| element(by.model('value')).sendKeys('6'); |
| expect(element(by.id('link-6')).getAttribute('href')).toMatch(/\/6$/); |
| |
| element(by.id('link-6')).click(); |
| |
| // At this point, we navigate away from an Angular page, so we need |
| // to use browser.driver to get the base webdriver. |
| browser.wait(function() { |
| return browser.driver.getCurrentUrl().then(function(url) { |
| return url.match(/\/6$/); |
| }); |
| }, 5000, 'page should navigate to /6'); |
| }); |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngSrc |
| * @restrict A |
| * @priority 99 |
| * |
| * @description |
| * Using Angular markup like `{{hash}}` in a `src` attribute doesn't |
| * work right: The browser will fetch from the URL with the literal |
| * text `{{hash}}` until Angular replaces the expression inside |
| * `{{hash}}`. The `ngSrc` directive solves this problem. |
| * |
| * The buggy way to write it: |
| * ```html |
| * <img src="http://www.gravatar.com/avatar/{{hash}}" alt="Description"/> |
| * ``` |
| * |
| * The correct way to write it: |
| * ```html |
| * <img ng-src="http://www.gravatar.com/avatar/{{hash}}" alt="Description" /> |
| * ``` |
| * |
| * @element IMG |
| * @param {template} ngSrc any string which can contain `{{}}` markup. |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngSrcset |
| * @restrict A |
| * @priority 99 |
| * |
| * @description |
| * Using Angular markup like `{{hash}}` in a `srcset` attribute doesn't |
| * work right: The browser will fetch from the URL with the literal |
| * text `{{hash}}` until Angular replaces the expression inside |
| * `{{hash}}`. The `ngSrcset` directive solves this problem. |
| * |
| * The buggy way to write it: |
| * ```html |
| * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description"/> |
| * ``` |
| * |
| * The correct way to write it: |
| * ```html |
| * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description" /> |
| * ``` |
| * |
| * @element IMG |
| * @param {template} ngSrcset any string which can contain `{{}}` markup. |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngDisabled |
| * @restrict A |
| * @priority 100 |
| * |
| * @description |
| * |
| * This directive sets the `disabled` attribute on the element if the |
| * {@link guide/expression expression} inside `ngDisabled` evaluates to truthy. |
| * |
| * A special directive is necessary because we cannot use interpolation inside the `disabled` |
| * attribute. The following example would make the button enabled on Chrome/Firefox |
| * but not on older IEs: |
| * |
| * ```html |
| * <!-- See below for an example of ng-disabled being used correctly --> |
| * <div ng-init="isDisabled = false"> |
| * <button disabled="{{isDisabled}}">Disabled</button> |
| * </div> |
| * ``` |
| * |
| * This is because the HTML specification does not require browsers to preserve the values of |
| * boolean attributes such as `disabled` (Their presence means true and their absence means false.) |
| * If we put an Angular interpolation expression into such an attribute then the |
| * binding information would be lost when the browser removes the attribute. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <label>Click me to toggle: <input type="checkbox" ng-model="checked"></label><br/> |
| <button ng-model="button" ng-disabled="checked">Button</button> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should toggle button', function() { |
| expect(element(by.css('button')).getAttribute('disabled')).toBeFalsy(); |
| element(by.model('checked')).click(); |
| expect(element(by.css('button')).getAttribute('disabled')).toBeTruthy(); |
| }); |
| </file> |
| </example> |
| * |
| * @element INPUT |
| * @param {expression} ngDisabled If the {@link guide/expression expression} is truthy, |
| * then the `disabled` attribute will be set on the element |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngChecked |
| * @restrict A |
| * @priority 100 |
| * |
| * @description |
| * Sets the `checked` attribute on the element, if the expression inside `ngChecked` is truthy. |
| * |
| * Note that this directive should not be used together with {@link ngModel `ngModel`}, |
| * as this can lead to unexpected behavior. |
| * |
| * ### Why do we need `ngChecked`? |
| * |
| * The HTML specification does not require browsers to preserve the values of boolean attributes |
| * such as checked. (Their presence means true and their absence means false.) |
| * If we put an Angular interpolation expression into such an attribute then the |
| * binding information would be lost when the browser removes the attribute. |
| * The `ngChecked` directive solves this problem for the `checked` attribute. |
| * This complementary directive is not removed by the browser and so provides |
| * a permanent reliable place to store the binding information. |
| * @example |
| <example> |
| <file name="index.html"> |
| <label>Check me to check both: <input type="checkbox" ng-model="master"></label><br/> |
| <input id="checkSlave" type="checkbox" ng-checked="master" aria-label="Slave input"> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check both checkBoxes', function() { |
| expect(element(by.id('checkSlave')).getAttribute('checked')).toBeFalsy(); |
| element(by.model('master')).click(); |
| expect(element(by.id('checkSlave')).getAttribute('checked')).toBeTruthy(); |
| }); |
| </file> |
| </example> |
| * |
| * @element INPUT |
| * @param {expression} ngChecked If the {@link guide/expression expression} is truthy, |
| * then the `checked` attribute will be set on the element |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngReadonly |
| * @restrict A |
| * @priority 100 |
| * |
| * @description |
| * The HTML specification does not require browsers to preserve the values of boolean attributes |
| * such as readonly. (Their presence means true and their absence means false.) |
| * If we put an Angular interpolation expression into such an attribute then the |
| * binding information would be lost when the browser removes the attribute. |
| * The `ngReadonly` directive solves this problem for the `readonly` attribute. |
| * This complementary directive is not removed by the browser and so provides |
| * a permanent reliable place to store the binding information. |
| * @example |
| <example> |
| <file name="index.html"> |
| <label>Check me to make text readonly: <input type="checkbox" ng-model="checked"></label><br/> |
| <input type="text" ng-readonly="checked" value="I'm Angular" aria-label="Readonly field" /> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should toggle readonly attr', function() { |
| expect(element(by.css('[type="text"]')).getAttribute('readonly')).toBeFalsy(); |
| element(by.model('checked')).click(); |
| expect(element(by.css('[type="text"]')).getAttribute('readonly')).toBeTruthy(); |
| }); |
| </file> |
| </example> |
| * |
| * @element INPUT |
| * @param {expression} ngReadonly If the {@link guide/expression expression} is truthy, |
| * then special attribute "readonly" will be set on the element |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngSelected |
| * @restrict A |
| * @priority 100 |
| * |
| * @description |
| * The HTML specification does not require browsers to preserve the values of boolean attributes |
| * such as selected. (Their presence means true and their absence means false.) |
| * If we put an Angular interpolation expression into such an attribute then the |
| * binding information would be lost when the browser removes the attribute. |
| * The `ngSelected` directive solves this problem for the `selected` attribute. |
| * This complementary directive is not removed by the browser and so provides |
| * a permanent reliable place to store the binding information. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <label>Check me to select: <input type="checkbox" ng-model="selected"></label><br/> |
| <select aria-label="ngSelected demo"> |
| <option>Hello!</option> |
| <option id="greet" ng-selected="selected">Greetings!</option> |
| </select> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should select Greetings!', function() { |
| expect(element(by.id('greet')).getAttribute('selected')).toBeFalsy(); |
| element(by.model('selected')).click(); |
| expect(element(by.id('greet')).getAttribute('selected')).toBeTruthy(); |
| }); |
| </file> |
| </example> |
| * |
| * @element OPTION |
| * @param {expression} ngSelected If the {@link guide/expression expression} is truthy, |
| * then special attribute "selected" will be set on the element |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngOpen |
| * @restrict A |
| * @priority 100 |
| * |
| * @description |
| * The HTML specification does not require browsers to preserve the values of boolean attributes |
| * such as open. (Their presence means true and their absence means false.) |
| * If we put an Angular interpolation expression into such an attribute then the |
| * binding information would be lost when the browser removes the attribute. |
| * The `ngOpen` directive solves this problem for the `open` attribute. |
| * This complementary directive is not removed by the browser and so provides |
| * a permanent reliable place to store the binding information. |
| * @example |
| <example> |
| <file name="index.html"> |
| <label>Check me check multiple: <input type="checkbox" ng-model="open"></label><br/> |
| <details id="details" ng-open="open"> |
| <summary>Show/Hide me</summary> |
| </details> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should toggle open', function() { |
| expect(element(by.id('details')).getAttribute('open')).toBeFalsy(); |
| element(by.model('open')).click(); |
| expect(element(by.id('details')).getAttribute('open')).toBeTruthy(); |
| }); |
| </file> |
| </example> |
| * |
| * @element DETAILS |
| * @param {expression} ngOpen If the {@link guide/expression expression} is truthy, |
| * then special attribute "open" will be set on the element |
| */ |
| |
| var ngAttributeAliasDirectives = {}; |
| |
| // boolean attrs are evaluated |
| forEach(BOOLEAN_ATTR, function(propName, attrName) { |
| // binding to multiple is not supported |
| if (propName == "multiple") return; |
| |
| function defaultLinkFn(scope, element, attr) { |
| scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) { |
| attr.$set(attrName, !!value); |
| }); |
| } |
| |
| var normalized = directiveNormalize('ng-' + attrName); |
| var linkFn = defaultLinkFn; |
| |
| if (propName === 'checked') { |
| linkFn = function(scope, element, attr) { |
| // ensuring ngChecked doesn't interfere with ngModel when both are set on the same input |
| if (attr.ngModel !== attr[normalized]) { |
| defaultLinkFn(scope, element, attr); |
| } |
| }; |
| } |
| |
| ngAttributeAliasDirectives[normalized] = function() { |
| return { |
| restrict: 'A', |
| priority: 100, |
| link: linkFn |
| }; |
| }; |
| }); |
| |
| // aliased input attrs are evaluated |
| forEach(ALIASED_ATTR, function(htmlAttr, ngAttr) { |
| ngAttributeAliasDirectives[ngAttr] = function() { |
| return { |
| priority: 100, |
| link: function(scope, element, attr) { |
| //special case ngPattern when a literal regular expression value |
| //is used as the expression (this way we don't have to watch anything). |
| if (ngAttr === "ngPattern" && attr.ngPattern.charAt(0) == "/") { |
| var match = attr.ngPattern.match(REGEX_STRING_REGEXP); |
| if (match) { |
| attr.$set("ngPattern", new RegExp(match[1], match[2])); |
| return; |
| } |
| } |
| |
| scope.$watch(attr[ngAttr], function ngAttrAliasWatchAction(value) { |
| attr.$set(ngAttr, value); |
| }); |
| } |
| }; |
| }; |
| }); |
| |
| // ng-src, ng-srcset, ng-href are interpolated |
| forEach(['src', 'srcset', 'href'], function(attrName) { |
| var normalized = directiveNormalize('ng-' + attrName); |
| ngAttributeAliasDirectives[normalized] = function() { |
| return { |
| priority: 99, // it needs to run after the attributes are interpolated |
| link: function(scope, element, attr) { |
| var propName = attrName, |
| name = attrName; |
| |
| if (attrName === 'href' && |
| toString.call(element.prop('href')) === '[object SVGAnimatedString]') { |
| name = 'xlinkHref'; |
| attr.$attr[name] = 'xlink:href'; |
| propName = null; |
| } |
| |
| attr.$observe(normalized, function(value) { |
| if (!value) { |
| if (attrName === 'href') { |
| attr.$set(name, null); |
| } |
| return; |
| } |
| |
| attr.$set(name, value); |
| |
| // on IE, if "ng:src" directive declaration is used and "src" attribute doesn't exist |
| // then calling element.setAttribute('src', 'foo') doesn't do anything, so we need |
| // to set the property as well to achieve the desired effect. |
| // we use attr[attrName] value since $set can sanitize the url. |
| if (msie && propName) element.prop(propName, attr[name]); |
| }); |
| } |
| }; |
| }; |
| }); |
| |
| /* global -nullFormCtrl, -SUBMITTED_CLASS, addSetValidityMethod: true |
| */ |
| var nullFormCtrl = { |
| $addControl: noop, |
| $$renameControl: nullFormRenameControl, |
| $removeControl: noop, |
| $setValidity: noop, |
| $setDirty: noop, |
| $setPristine: noop, |
| $setSubmitted: noop |
| }, |
| SUBMITTED_CLASS = 'ng-submitted'; |
| |
| function nullFormRenameControl(control, name) { |
| control.$name = name; |
| } |
| |
| /** |
| * @ngdoc type |
| * @name form.FormController |
| * |
| * @property {boolean} $pristine True if user has not interacted with the form yet. |
| * @property {boolean} $dirty True if user has already interacted with the form. |
| * @property {boolean} $valid True if all of the containing forms and controls are valid. |
| * @property {boolean} $invalid True if at least one containing control or form is invalid. |
| * @property {boolean} $pending True if at least one containing control or form is pending. |
| * @property {boolean} $submitted True if user has submitted the form even if its invalid. |
| * |
| * @property {Object} $error Is an object hash, containing references to controls or |
| * forms with failing validators, where: |
| * |
| * - keys are validation tokens (error names), |
| * - values are arrays of controls or forms that have a failing validator for given error name. |
| * |
| * Built-in validation tokens: |
| * |
| * - `email` |
| * - `max` |
| * - `maxlength` |
| * - `min` |
| * - `minlength` |
| * - `number` |
| * - `pattern` |
| * - `required` |
| * - `url` |
| * - `date` |
| * - `datetimelocal` |
| * - `time` |
| * - `week` |
| * - `month` |
| * |
| * @description |
| * `FormController` keeps track of all its controls and nested forms as well as the state of them, |
| * such as being valid/invalid or dirty/pristine. |
| * |
| * Each {@link ng.directive:form form} directive creates an instance |
| * of `FormController`. |
| * |
| */ |
| //asks for $scope to fool the BC controller module |
| FormController.$inject = ['$element', '$attrs', '$scope', '$animate', '$interpolate']; |
| function FormController(element, attrs, $scope, $animate, $interpolate) { |
| var form = this, |
| controls = []; |
| |
| // init state |
| form.$error = {}; |
| form.$$success = {}; |
| form.$pending = undefined; |
| form.$name = $interpolate(attrs.name || attrs.ngForm || '')($scope); |
| form.$dirty = false; |
| form.$pristine = true; |
| form.$valid = true; |
| form.$invalid = false; |
| form.$submitted = false; |
| form.$$parentForm = nullFormCtrl; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$rollbackViewValue |
| * |
| * @description |
| * Rollback all form controls pending updates to the `$modelValue`. |
| * |
| * Updates may be pending by a debounced event or because the input is waiting for a some future |
| * event defined in `ng-model-options`. This method is typically needed by the reset button of |
| * a form that uses `ng-model-options` to pend updates. |
| */ |
| form.$rollbackViewValue = function() { |
| forEach(controls, function(control) { |
| control.$rollbackViewValue(); |
| }); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$commitViewValue |
| * |
| * @description |
| * Commit all form controls pending updates to the `$modelValue`. |
| * |
| * Updates may be pending by a debounced event or because the input is waiting for a some future |
| * event defined in `ng-model-options`. This method is rarely needed as `NgModelController` |
| * usually handles calling this in response to input events. |
| */ |
| form.$commitViewValue = function() { |
| forEach(controls, function(control) { |
| control.$commitViewValue(); |
| }); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$addControl |
| * @param {object} control control object, either a {@link form.FormController} or an |
| * {@link ngModel.NgModelController} |
| * |
| * @description |
| * Register a control with the form. Input elements using ngModelController do this automatically |
| * when they are linked. |
| * |
| * Note that the current state of the control will not be reflected on the new parent form. This |
| * is not an issue with normal use, as freshly compiled and linked controls are in a `$pristine` |
| * state. |
| * |
| * However, if the method is used programmatically, for example by adding dynamically created controls, |
| * or controls that have been previously removed without destroying their corresponding DOM element, |
| * it's the developers responsiblity to make sure the current state propagates to the parent form. |
| * |
| * For example, if an input control is added that is already `$dirty` and has `$error` properties, |
| * calling `$setDirty()` and `$validate()` afterwards will propagate the state to the parent form. |
| */ |
| form.$addControl = function(control) { |
| // Breaking change - before, inputs whose name was "hasOwnProperty" were quietly ignored |
| // and not added to the scope. Now we throw an error. |
| assertNotHasOwnProperty(control.$name, 'input'); |
| controls.push(control); |
| |
| if (control.$name) { |
| form[control.$name] = control; |
| } |
| |
| control.$$parentForm = form; |
| }; |
| |
| // Private API: rename a form control |
| form.$$renameControl = function(control, newName) { |
| var oldName = control.$name; |
| |
| if (form[oldName] === control) { |
| delete form[oldName]; |
| } |
| form[newName] = control; |
| control.$name = newName; |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$removeControl |
| * @param {object} control control object, either a {@link form.FormController} or an |
| * {@link ngModel.NgModelController} |
| * |
| * @description |
| * Deregister a control from the form. |
| * |
| * Input elements using ngModelController do this automatically when they are destroyed. |
| * |
| * Note that only the removed control's validation state (`$errors`etc.) will be removed from the |
| * form. `$dirty`, `$submitted` states will not be changed, because the expected behavior can be |
| * different from case to case. For example, removing the only `$dirty` control from a form may or |
| * may not mean that the form is still `$dirty`. |
| */ |
| form.$removeControl = function(control) { |
| if (control.$name && form[control.$name] === control) { |
| delete form[control.$name]; |
| } |
| forEach(form.$pending, function(value, name) { |
| form.$setValidity(name, null, control); |
| }); |
| forEach(form.$error, function(value, name) { |
| form.$setValidity(name, null, control); |
| }); |
| forEach(form.$$success, function(value, name) { |
| form.$setValidity(name, null, control); |
| }); |
| |
| arrayRemove(controls, control); |
| control.$$parentForm = nullFormCtrl; |
| }; |
| |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$setValidity |
| * |
| * @description |
| * Sets the validity of a form control. |
| * |
| * This method will also propagate to parent forms. |
| */ |
| addSetValidityMethod({ |
| ctrl: this, |
| $element: element, |
| set: function(object, property, controller) { |
| var list = object[property]; |
| if (!list) { |
| object[property] = [controller]; |
| } else { |
| var index = list.indexOf(controller); |
| if (index === -1) { |
| list.push(controller); |
| } |
| } |
| }, |
| unset: function(object, property, controller) { |
| var list = object[property]; |
| if (!list) { |
| return; |
| } |
| arrayRemove(list, controller); |
| if (list.length === 0) { |
| delete object[property]; |
| } |
| }, |
| $animate: $animate |
| }); |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$setDirty |
| * |
| * @description |
| * Sets the form to a dirty state. |
| * |
| * This method can be called to add the 'ng-dirty' class and set the form to a dirty |
| * state (ng-dirty class). This method will also propagate to parent forms. |
| */ |
| form.$setDirty = function() { |
| $animate.removeClass(element, PRISTINE_CLASS); |
| $animate.addClass(element, DIRTY_CLASS); |
| form.$dirty = true; |
| form.$pristine = false; |
| form.$$parentForm.$setDirty(); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$setPristine |
| * |
| * @description |
| * Sets the form to its pristine state. |
| * |
| * This method can be called to remove the 'ng-dirty' class and set the form to its pristine |
| * state (ng-pristine class). This method will also propagate to all the controls contained |
| * in this form. |
| * |
| * Setting a form back to a pristine state is often useful when we want to 'reuse' a form after |
| * saving or resetting it. |
| */ |
| form.$setPristine = function() { |
| $animate.setClass(element, PRISTINE_CLASS, DIRTY_CLASS + ' ' + SUBMITTED_CLASS); |
| form.$dirty = false; |
| form.$pristine = true; |
| form.$submitted = false; |
| forEach(controls, function(control) { |
| control.$setPristine(); |
| }); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$setUntouched |
| * |
| * @description |
| * Sets the form to its untouched state. |
| * |
| * This method can be called to remove the 'ng-touched' class and set the form controls to their |
| * untouched state (ng-untouched class). |
| * |
| * Setting a form controls back to their untouched state is often useful when setting the form |
| * back to its pristine state. |
| */ |
| form.$setUntouched = function() { |
| forEach(controls, function(control) { |
| control.$setUntouched(); |
| }); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name form.FormController#$setSubmitted |
| * |
| * @description |
| * Sets the form to its submitted state. |
| */ |
| form.$setSubmitted = function() { |
| $animate.addClass(element, SUBMITTED_CLASS); |
| form.$submitted = true; |
| form.$$parentForm.$setSubmitted(); |
| }; |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name ngForm |
| * @restrict EAC |
| * |
| * @description |
| * Nestable alias of {@link ng.directive:form `form`} directive. HTML |
| * does not allow nesting of form elements. It is useful to nest forms, for example if the validity of a |
| * sub-group of controls needs to be determined. |
| * |
| * Note: the purpose of `ngForm` is to group controls, |
| * but not to be a replacement for the `<form>` tag with all of its capabilities |
| * (e.g. posting to the server, ...). |
| * |
| * @param {string=} ngForm|name Name of the form. If specified, the form controller will be published into |
| * related scope, under this name. |
| * |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name form |
| * @restrict E |
| * |
| * @description |
| * Directive that instantiates |
| * {@link form.FormController FormController}. |
| * |
| * If the `name` attribute is specified, the form controller is published onto the current scope under |
| * this name. |
| * |
| * # Alias: {@link ng.directive:ngForm `ngForm`} |
| * |
| * In Angular, forms can be nested. This means that the outer form is valid when all of the child |
| * forms are valid as well. However, browsers do not allow nesting of `<form>` elements, so |
| * Angular provides the {@link ng.directive:ngForm `ngForm`} directive which behaves identically to |
| * `<form>` but can be nested. This allows you to have nested forms, which is very useful when |
| * using Angular validation directives in forms that are dynamically generated using the |
| * {@link ng.directive:ngRepeat `ngRepeat`} directive. Since you cannot dynamically generate the `name` |
| * attribute of input elements using interpolation, you have to wrap each set of repeated inputs in an |
| * `ngForm` directive and nest these in an outer `form` element. |
| * |
| * |
| * # CSS classes |
| * - `ng-valid` is set if the form is valid. |
| * - `ng-invalid` is set if the form is invalid. |
| * - `ng-pending` is set if the form is pending. |
| * - `ng-pristine` is set if the form is pristine. |
| * - `ng-dirty` is set if the form is dirty. |
| * - `ng-submitted` is set if the form was submitted. |
| * |
| * Keep in mind that ngAnimate can detect each of these classes when added and removed. |
| * |
| * |
| * # Submitting a form and preventing the default action |
| * |
| * Since the role of forms in client-side Angular applications is different than in classical |
| * roundtrip apps, it is desirable for the browser not to translate the form submission into a full |
| * page reload that sends the data to the server. Instead some javascript logic should be triggered |
| * to handle the form submission in an application-specific way. |
| * |
| * For this reason, Angular prevents the default action (form submission to the server) unless the |
| * `<form>` element has an `action` attribute specified. |
| * |
| * You can use one of the following two ways to specify what javascript method should be called when |
| * a form is submitted: |
| * |
| * - {@link ng.directive:ngSubmit ngSubmit} directive on the form element |
| * - {@link ng.directive:ngClick ngClick} directive on the first |
| * button or input field of type submit (input[type=submit]) |
| * |
| * To prevent double execution of the handler, use only one of the {@link ng.directive:ngSubmit ngSubmit} |
| * or {@link ng.directive:ngClick ngClick} directives. |
| * This is because of the following form submission rules in the HTML specification: |
| * |
| * - If a form has only one input field then hitting enter in this field triggers form submit |
| * (`ngSubmit`) |
| * - if a form has 2+ input fields and no buttons or input[type=submit] then hitting enter |
| * doesn't trigger submit |
| * - if a form has one or more input fields and one or more buttons or input[type=submit] then |
| * hitting enter in any of the input fields will trigger the click handler on the *first* button or |
| * input[type=submit] (`ngClick`) *and* a submit handler on the enclosing form (`ngSubmit`) |
| * |
| * Any pending `ngModelOptions` changes will take place immediately when an enclosing form is |
| * submitted. Note that `ngClick` events will occur before the model is updated. Use `ngSubmit` |
| * to have access to the updated model. |
| * |
| * ## Animation Hooks |
| * |
| * Animations in ngForm are triggered when any of the associated CSS classes are added and removed. |
| * These classes are: `.ng-pristine`, `.ng-dirty`, `.ng-invalid` and `.ng-valid` as well as any |
| * other validations that are performed within the form. Animations in ngForm are similar to how |
| * they work in ngClass and animations can be hooked into using CSS transitions, keyframes as well |
| * as JS animations. |
| * |
| * The following example shows a simple way to utilize CSS transitions to style a form element |
| * that has been rendered as invalid after it has been validated: |
| * |
| * <pre> |
| * //be sure to include ngAnimate as a module to hook into more |
| * //advanced animations |
| * .my-form { |
| * transition:0.5s linear all; |
| * background: white; |
| * } |
| * .my-form.ng-invalid { |
| * background: red; |
| * color:white; |
| * } |
| * </pre> |
| * |
| * @example |
| <example deps="angular-animate.js" animations="true" fixBase="true" module="formExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('formExample', []) |
| .controller('FormController', ['$scope', function($scope) { |
| $scope.userType = 'guest'; |
| }]); |
| </script> |
| <style> |
| .my-form { |
| transition:all linear 0.5s; |
| background: transparent; |
| } |
| .my-form.ng-invalid { |
| background: red; |
| } |
| </style> |
| <form name="myForm" ng-controller="FormController" class="my-form"> |
| userType: <input name="input" ng-model="userType" required> |
| <span class="error" ng-show="myForm.input.$error.required">Required!</span><br> |
| <code>userType = {{userType}}</code><br> |
| <code>myForm.input.$valid = {{myForm.input.$valid}}</code><br> |
| <code>myForm.input.$error = {{myForm.input.$error}}</code><br> |
| <code>myForm.$valid = {{myForm.$valid}}</code><br> |
| <code>myForm.$error.required = {{!!myForm.$error.required}}</code><br> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should initialize to model', function() { |
| var userType = element(by.binding('userType')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| |
| expect(userType.getText()).toContain('guest'); |
| expect(valid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| var userType = element(by.binding('userType')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var userInput = element(by.model('userType')); |
| |
| userInput.clear(); |
| userInput.sendKeys(''); |
| |
| expect(userType.getText()).toEqual('userType ='); |
| expect(valid.getText()).toContain('false'); |
| }); |
| </file> |
| </example> |
| * |
| * @param {string=} name Name of the form. If specified, the form controller will be published into |
| * related scope, under this name. |
| */ |
| var formDirectiveFactory = function(isNgForm) { |
| return ['$timeout', '$parse', function($timeout, $parse) { |
| var formDirective = { |
| name: 'form', |
| restrict: isNgForm ? 'EAC' : 'E', |
| require: ['form', '^^?form'], //first is the form's own ctrl, second is an optional parent form |
| controller: FormController, |
| compile: function ngFormCompile(formElement, attr) { |
| // Setup initial state of the control |
| formElement.addClass(PRISTINE_CLASS).addClass(VALID_CLASS); |
| |
| var nameAttr = attr.name ? 'name' : (isNgForm && attr.ngForm ? 'ngForm' : false); |
| |
| return { |
| pre: function ngFormPreLink(scope, formElement, attr, ctrls) { |
| var controller = ctrls[0]; |
| |
| // if `action` attr is not present on the form, prevent the default action (submission) |
| if (!('action' in attr)) { |
| // we can't use jq events because if a form is destroyed during submission the default |
| // action is not prevented. see #1238 |
| // |
| // IE 9 is not affected because it doesn't fire a submit event and try to do a full |
| // page reload if the form was destroyed by submission of the form via a click handler |
| // on a button in the form. Looks like an IE9 specific bug. |
| var handleFormSubmission = function(event) { |
| scope.$apply(function() { |
| controller.$commitViewValue(); |
| controller.$setSubmitted(); |
| }); |
| |
| event.preventDefault(); |
| }; |
| |
| addEventListenerFn(formElement[0], 'submit', handleFormSubmission); |
| |
| // unregister the preventDefault listener so that we don't not leak memory but in a |
| // way that will achieve the prevention of the default action. |
| formElement.on('$destroy', function() { |
| $timeout(function() { |
| removeEventListenerFn(formElement[0], 'submit', handleFormSubmission); |
| }, 0, false); |
| }); |
| } |
| |
| var parentFormCtrl = ctrls[1] || controller.$$parentForm; |
| parentFormCtrl.$addControl(controller); |
| |
| var setter = nameAttr ? getSetter(controller.$name) : noop; |
| |
| if (nameAttr) { |
| setter(scope, controller); |
| attr.$observe(nameAttr, function(newValue) { |
| if (controller.$name === newValue) return; |
| setter(scope, undefined); |
| controller.$$parentForm.$$renameControl(controller, newValue); |
| setter = getSetter(controller.$name); |
| setter(scope, controller); |
| }); |
| } |
| formElement.on('$destroy', function() { |
| controller.$$parentForm.$removeControl(controller); |
| setter(scope, undefined); |
| extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards |
| }); |
| } |
| }; |
| } |
| }; |
| |
| return formDirective; |
| |
| function getSetter(expression) { |
| if (expression === '') { |
| //create an assignable expression, so forms with an empty name can be renamed later |
| return $parse('this[""]').assign; |
| } |
| return $parse(expression).assign || noop; |
| } |
| }]; |
| }; |
| |
| var formDirective = formDirectiveFactory(); |
| var ngFormDirective = formDirectiveFactory(true); |
| |
| /* global VALID_CLASS: false, |
| INVALID_CLASS: false, |
| PRISTINE_CLASS: false, |
| DIRTY_CLASS: false, |
| UNTOUCHED_CLASS: false, |
| TOUCHED_CLASS: false, |
| ngModelMinErr: false, |
| */ |
| |
| // Regex code is obtained from SO: https://stackoverflow.com/questions/3143070/javascript-regex-iso-datetime#answer-3143231 |
| var ISO_DATE_REGEXP = /\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/; |
| var URL_REGEXP = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/; |
| var EMAIL_REGEXP = /^[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i; |
| var NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))([eE][+-]?\d+)?\s*$/; |
| var DATE_REGEXP = /^(\d{4})-(\d{2})-(\d{2})$/; |
| var DATETIMELOCAL_REGEXP = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d)(?::(\d\d)(\.\d{1,3})?)?$/; |
| var WEEK_REGEXP = /^(\d{4})-W(\d\d)$/; |
| var MONTH_REGEXP = /^(\d{4})-(\d\d)$/; |
| var TIME_REGEXP = /^(\d\d):(\d\d)(?::(\d\d)(\.\d{1,3})?)?$/; |
| |
| var inputType = { |
| |
| /** |
| * @ngdoc input |
| * @name input[text] |
| * |
| * @description |
| * Standard HTML text input with angular data binding, inherited by most of the `input` elements. |
| * |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required Adds `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than |
| * minlength. |
| * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than |
| * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of |
| * any length. |
| * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string |
| * that contains the regular expression body that will be converted to a regular expression |
| * as in the ngPattern directive. |
| * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match |
| * a RegExp found by evaluating the Angular expression given in the attribute value. |
| * If the expression evaluates to a RegExp object, then this is used directly. |
| * If the expression evaluates to a string, then it will be converted to a RegExp |
| * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to |
| * `new RegExp('^abc$')`.<br /> |
| * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to |
| * start at the index of the last search's match, thus not taking the whole input value into |
| * account. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * @param {boolean=} [ngTrim=true] If set to false Angular will not automatically trim the input. |
| * This parameter is ignored for input[type=password] controls, which will never trim the |
| * input. |
| * |
| * @example |
| <example name="text-input-directive" module="textInputExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('textInputExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.example = { |
| text: 'guest', |
| word: /^\s*\w*\s*$/ |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="ExampleController"> |
| <label>Single word: |
| <input type="text" name="input" ng-model="example.text" |
| ng-pattern="example.word" required ng-trim="false"> |
| </label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.pattern"> |
| Single word only!</span> |
| </div> |
| <tt>text = {{example.text}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var text = element(by.binding('example.text')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.text')); |
| |
| it('should initialize to model', function() { |
| expect(text.getText()).toContain('guest'); |
| expect(valid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| input.clear(); |
| input.sendKeys(''); |
| |
| expect(text.getText()).toEqual('text ='); |
| expect(valid.getText()).toContain('false'); |
| }); |
| |
| it('should be invalid if multi word', function() { |
| input.clear(); |
| input.sendKeys('hello world'); |
| |
| expect(valid.getText()).toContain('false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'text': textInputType, |
| |
| /** |
| * @ngdoc input |
| * @name input[date] |
| * |
| * @description |
| * Input with date validation and transformation. In browsers that do not yet support |
| * the HTML5 date input, a text element will be used. In that case, text must be entered in a valid ISO-8601 |
| * date format (yyyy-MM-dd), for example: `2009-01-06`. Since many |
| * modern browsers do not yet support this input type, it is important to provide cues to users on the |
| * expected input format via a placeholder or label. |
| * |
| * The model must always be a Date object, otherwise Angular will throw an error. |
| * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string. |
| * |
| * The timezone to be used to read/write the `Date` instance in the model can be defined using |
| * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. This must be a |
| * valid ISO date string (yyyy-MM-dd). You can also use interpolation inside this attribute |
| * (e.g. `min="{{minDate | date:'yyyy-MM-dd'}}"`). Note that `min` will also add native HTML5 |
| * constraint validation. |
| * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. This must be |
| * a valid ISO date string (yyyy-MM-dd). You can also use interpolation inside this attribute |
| * (e.g. `max="{{maxDate | date:'yyyy-MM-dd'}}"`). Note that `max` will also add native HTML5 |
| * constraint validation. |
| * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO date string |
| * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute. |
| * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO date string |
| * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="date-input-directive" module="dateInputExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('dateInputExample', []) |
| .controller('DateController', ['$scope', function($scope) { |
| $scope.example = { |
| value: new Date(2013, 9, 22) |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="DateController as dateCtrl"> |
| <label for="exampleInput">Pick a date in 2013:</label> |
| <input type="date" id="exampleInput" name="input" ng-model="example.value" |
| placeholder="yyyy-MM-dd" min="2013-01-01" max="2013-12-31" required /> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.date"> |
| Not a valid date!</span> |
| </div> |
| <tt>value = {{example.value | date: "yyyy-MM-dd"}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var value = element(by.binding('example.value | date: "yyyy-MM-dd"')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.value')); |
| |
| // currently protractor/webdriver does not support |
| // sending keys to all known HTML5 input controls |
| // for various browsers (see https://github.com/angular/protractor/issues/562). |
| function setInput(val) { |
| // set the value of the element and force validation. |
| var scr = "var ipt = document.getElementById('exampleInput'); " + |
| "ipt.value = '" + val + "';" + |
| "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });"; |
| browser.executeScript(scr); |
| } |
| |
| it('should initialize to model', function() { |
| expect(value.getText()).toContain('2013-10-22'); |
| expect(valid.getText()).toContain('myForm.input.$valid = true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| setInput(''); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| |
| it('should be invalid if over max', function() { |
| setInput('2015-01-01'); |
| expect(value.getText()).toContain(''); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'date': createDateInputType('date', DATE_REGEXP, |
| createDateParser(DATE_REGEXP, ['yyyy', 'MM', 'dd']), |
| 'yyyy-MM-dd'), |
| |
| /** |
| * @ngdoc input |
| * @name input[datetime-local] |
| * |
| * @description |
| * Input with datetime validation and transformation. In browsers that do not yet support |
| * the HTML5 date input, a text element will be used. In that case, the text must be entered in a valid ISO-8601 |
| * local datetime format (yyyy-MM-ddTHH:mm:ss), for example: `2010-12-28T14:57:00`. |
| * |
| * The model must always be a Date object, otherwise Angular will throw an error. |
| * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string. |
| * |
| * The timezone to be used to read/write the `Date` instance in the model can be defined using |
| * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. |
| * This must be a valid ISO datetime format (yyyy-MM-ddTHH:mm:ss). You can also use interpolation |
| * inside this attribute (e.g. `min="{{minDatetimeLocal | date:'yyyy-MM-ddTHH:mm:ss'}}"`). |
| * Note that `min` will also add native HTML5 constraint validation. |
| * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. |
| * This must be a valid ISO datetime format (yyyy-MM-ddTHH:mm:ss). You can also use interpolation |
| * inside this attribute (e.g. `max="{{maxDatetimeLocal | date:'yyyy-MM-ddTHH:mm:ss'}}"`). |
| * Note that `max` will also add native HTML5 constraint validation. |
| * @param {(date|string)=} ngMin Sets the `min` validation error key to the Date / ISO datetime string |
| * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute. |
| * @param {(date|string)=} ngMax Sets the `max` validation error key to the Date / ISO datetime string |
| * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="datetimelocal-input-directive" module="dateExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('dateExample', []) |
| .controller('DateController', ['$scope', function($scope) { |
| $scope.example = { |
| value: new Date(2010, 11, 28, 14, 57) |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="DateController as dateCtrl"> |
| <label for="exampleInput">Pick a date between in 2013:</label> |
| <input type="datetime-local" id="exampleInput" name="input" ng-model="example.value" |
| placeholder="yyyy-MM-ddTHH:mm:ss" min="2001-01-01T00:00:00" max="2013-12-31T00:00:00" required /> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.datetimelocal"> |
| Not a valid date!</span> |
| </div> |
| <tt>value = {{example.value | date: "yyyy-MM-ddTHH:mm:ss"}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var value = element(by.binding('example.value | date: "yyyy-MM-ddTHH:mm:ss"')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.value')); |
| |
| // currently protractor/webdriver does not support |
| // sending keys to all known HTML5 input controls |
| // for various browsers (https://github.com/angular/protractor/issues/562). |
| function setInput(val) { |
| // set the value of the element and force validation. |
| var scr = "var ipt = document.getElementById('exampleInput'); " + |
| "ipt.value = '" + val + "';" + |
| "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });"; |
| browser.executeScript(scr); |
| } |
| |
| it('should initialize to model', function() { |
| expect(value.getText()).toContain('2010-12-28T14:57:00'); |
| expect(valid.getText()).toContain('myForm.input.$valid = true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| setInput(''); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| |
| it('should be invalid if over max', function() { |
| setInput('2015-01-01T23:59:00'); |
| expect(value.getText()).toContain(''); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'datetime-local': createDateInputType('datetimelocal', DATETIMELOCAL_REGEXP, |
| createDateParser(DATETIMELOCAL_REGEXP, ['yyyy', 'MM', 'dd', 'HH', 'mm', 'ss', 'sss']), |
| 'yyyy-MM-ddTHH:mm:ss.sss'), |
| |
| /** |
| * @ngdoc input |
| * @name input[time] |
| * |
| * @description |
| * Input with time validation and transformation. In browsers that do not yet support |
| * the HTML5 date input, a text element will be used. In that case, the text must be entered in a valid ISO-8601 |
| * local time format (HH:mm:ss), for example: `14:57:00`. Model must be a Date object. This binding will always output a |
| * Date object to the model of January 1, 1970, or local date `new Date(1970, 0, 1, HH, mm, ss)`. |
| * |
| * The model must always be a Date object, otherwise Angular will throw an error. |
| * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string. |
| * |
| * The timezone to be used to read/write the `Date` instance in the model can be defined using |
| * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. |
| * This must be a valid ISO time format (HH:mm:ss). You can also use interpolation inside this |
| * attribute (e.g. `min="{{minTime | date:'HH:mm:ss'}}"`). Note that `min` will also add |
| * native HTML5 constraint validation. |
| * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. |
| * This must be a valid ISO time format (HH:mm:ss). You can also use interpolation inside this |
| * attribute (e.g. `max="{{maxTime | date:'HH:mm:ss'}}"`). Note that `max` will also add |
| * native HTML5 constraint validation. |
| * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO time string the |
| * `ngMin` expression evaluates to. Note that it does not set the `min` attribute. |
| * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO time string the |
| * `ngMax` expression evaluates to. Note that it does not set the `max` attribute. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="time-input-directive" module="timeExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('timeExample', []) |
| .controller('DateController', ['$scope', function($scope) { |
| $scope.example = { |
| value: new Date(1970, 0, 1, 14, 57, 0) |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="DateController as dateCtrl"> |
| <label for="exampleInput">Pick a between 8am and 5pm:</label> |
| <input type="time" id="exampleInput" name="input" ng-model="example.value" |
| placeholder="HH:mm:ss" min="08:00:00" max="17:00:00" required /> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.time"> |
| Not a valid date!</span> |
| </div> |
| <tt>value = {{example.value | date: "HH:mm:ss"}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var value = element(by.binding('example.value | date: "HH:mm:ss"')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.value')); |
| |
| // currently protractor/webdriver does not support |
| // sending keys to all known HTML5 input controls |
| // for various browsers (https://github.com/angular/protractor/issues/562). |
| function setInput(val) { |
| // set the value of the element and force validation. |
| var scr = "var ipt = document.getElementById('exampleInput'); " + |
| "ipt.value = '" + val + "';" + |
| "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });"; |
| browser.executeScript(scr); |
| } |
| |
| it('should initialize to model', function() { |
| expect(value.getText()).toContain('14:57:00'); |
| expect(valid.getText()).toContain('myForm.input.$valid = true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| setInput(''); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| |
| it('should be invalid if over max', function() { |
| setInput('23:59:00'); |
| expect(value.getText()).toContain(''); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'time': createDateInputType('time', TIME_REGEXP, |
| createDateParser(TIME_REGEXP, ['HH', 'mm', 'ss', 'sss']), |
| 'HH:mm:ss.sss'), |
| |
| /** |
| * @ngdoc input |
| * @name input[week] |
| * |
| * @description |
| * Input with week-of-the-year validation and transformation to Date. In browsers that do not yet support |
| * the HTML5 week input, a text element will be used. In that case, the text must be entered in a valid ISO-8601 |
| * week format (yyyy-W##), for example: `2013-W02`. |
| * |
| * The model must always be a Date object, otherwise Angular will throw an error. |
| * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string. |
| * |
| * The timezone to be used to read/write the `Date` instance in the model can be defined using |
| * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. |
| * This must be a valid ISO week format (yyyy-W##). You can also use interpolation inside this |
| * attribute (e.g. `min="{{minWeek | date:'yyyy-Www'}}"`). Note that `min` will also add |
| * native HTML5 constraint validation. |
| * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. |
| * This must be a valid ISO week format (yyyy-W##). You can also use interpolation inside this |
| * attribute (e.g. `max="{{maxWeek | date:'yyyy-Www'}}"`). Note that `max` will also add |
| * native HTML5 constraint validation. |
| * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO week string |
| * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute. |
| * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO week string |
| * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="week-input-directive" module="weekExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('weekExample', []) |
| .controller('DateController', ['$scope', function($scope) { |
| $scope.example = { |
| value: new Date(2013, 0, 3) |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="DateController as dateCtrl"> |
| <label>Pick a date between in 2013: |
| <input id="exampleInput" type="week" name="input" ng-model="example.value" |
| placeholder="YYYY-W##" min="2012-W32" |
| max="2013-W52" required /> |
| </label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.week"> |
| Not a valid date!</span> |
| </div> |
| <tt>value = {{example.value | date: "yyyy-Www"}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var value = element(by.binding('example.value | date: "yyyy-Www"')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.value')); |
| |
| // currently protractor/webdriver does not support |
| // sending keys to all known HTML5 input controls |
| // for various browsers (https://github.com/angular/protractor/issues/562). |
| function setInput(val) { |
| // set the value of the element and force validation. |
| var scr = "var ipt = document.getElementById('exampleInput'); " + |
| "ipt.value = '" + val + "';" + |
| "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });"; |
| browser.executeScript(scr); |
| } |
| |
| it('should initialize to model', function() { |
| expect(value.getText()).toContain('2013-W01'); |
| expect(valid.getText()).toContain('myForm.input.$valid = true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| setInput(''); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| |
| it('should be invalid if over max', function() { |
| setInput('2015-W01'); |
| expect(value.getText()).toContain(''); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'week': createDateInputType('week', WEEK_REGEXP, weekParser, 'yyyy-Www'), |
| |
| /** |
| * @ngdoc input |
| * @name input[month] |
| * |
| * @description |
| * Input with month validation and transformation. In browsers that do not yet support |
| * the HTML5 month input, a text element will be used. In that case, the text must be entered in a valid ISO-8601 |
| * month format (yyyy-MM), for example: `2009-01`. |
| * |
| * The model must always be a Date object, otherwise Angular will throw an error. |
| * Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string. |
| * If the model is not set to the first of the month, the next view to model update will set it |
| * to the first of the month. |
| * |
| * The timezone to be used to read/write the `Date` instance in the model can be defined using |
| * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. |
| * This must be a valid ISO month format (yyyy-MM). You can also use interpolation inside this |
| * attribute (e.g. `min="{{minMonth | date:'yyyy-MM'}}"`). Note that `min` will also add |
| * native HTML5 constraint validation. |
| * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. |
| * This must be a valid ISO month format (yyyy-MM). You can also use interpolation inside this |
| * attribute (e.g. `max="{{maxMonth | date:'yyyy-MM'}}"`). Note that `max` will also add |
| * native HTML5 constraint validation. |
| * @param {(date|string)=} ngMin Sets the `min` validation constraint to the Date / ISO week string |
| * the `ngMin` expression evaluates to. Note that it does not set the `min` attribute. |
| * @param {(date|string)=} ngMax Sets the `max` validation constraint to the Date / ISO week string |
| * the `ngMax` expression evaluates to. Note that it does not set the `max` attribute. |
| |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="month-input-directive" module="monthExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('monthExample', []) |
| .controller('DateController', ['$scope', function($scope) { |
| $scope.example = { |
| value: new Date(2013, 9, 1) |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="DateController as dateCtrl"> |
| <label for="exampleInput">Pick a month in 2013:</label> |
| <input id="exampleInput" type="month" name="input" ng-model="example.value" |
| placeholder="yyyy-MM" min="2013-01" max="2013-12" required /> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.month"> |
| Not a valid month!</span> |
| </div> |
| <tt>value = {{example.value | date: "yyyy-MM"}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var value = element(by.binding('example.value | date: "yyyy-MM"')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.value')); |
| |
| // currently protractor/webdriver does not support |
| // sending keys to all known HTML5 input controls |
| // for various browsers (https://github.com/angular/protractor/issues/562). |
| function setInput(val) { |
| // set the value of the element and force validation. |
| var scr = "var ipt = document.getElementById('exampleInput'); " + |
| "ipt.value = '" + val + "';" + |
| "angular.element(ipt).scope().$apply(function(s) { s.myForm[ipt.name].$setViewValue('" + val + "'); });"; |
| browser.executeScript(scr); |
| } |
| |
| it('should initialize to model', function() { |
| expect(value.getText()).toContain('2013-10'); |
| expect(valid.getText()).toContain('myForm.input.$valid = true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| setInput(''); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| |
| it('should be invalid if over max', function() { |
| setInput('2015-01'); |
| expect(value.getText()).toContain(''); |
| expect(valid.getText()).toContain('myForm.input.$valid = false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'month': createDateInputType('month', MONTH_REGEXP, |
| createDateParser(MONTH_REGEXP, ['yyyy', 'MM']), |
| 'yyyy-MM'), |
| |
| /** |
| * @ngdoc input |
| * @name input[number] |
| * |
| * @description |
| * Text input with number validation and transformation. Sets the `number` validation |
| * error if not a valid number. |
| * |
| * <div class="alert alert-warning"> |
| * The model must always be of type `number` otherwise Angular will throw an error. |
| * Be aware that a string containing a number is not enough. See the {@link ngModel:numfmt} |
| * error docs for more information and an example of how to convert your model if necessary. |
| * </div> |
| * |
| * ## Issues with HTML5 constraint validation |
| * |
| * In browsers that follow the |
| * [HTML5 specification](https://html.spec.whatwg.org/multipage/forms.html#number-state-%28type=number%29), |
| * `input[number]` does not work as expected with {@link ngModelOptions `ngModelOptions.allowInvalid`}. |
| * If a non-number is entered in the input, the browser will report the value as an empty string, |
| * which means the view / model values in `ngModel` and subsequently the scope value |
| * will also be an empty string. |
| * |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} min Sets the `min` validation error key if the value entered is less than `min`. |
| * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than |
| * minlength. |
| * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than |
| * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of |
| * any length. |
| * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string |
| * that contains the regular expression body that will be converted to a regular expression |
| * as in the ngPattern directive. |
| * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match |
| * a RegExp found by evaluating the Angular expression given in the attribute value. |
| * If the expression evaluates to a RegExp object, then this is used directly. |
| * If the expression evaluates to a string, then it will be converted to a RegExp |
| * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to |
| * `new RegExp('^abc$')`.<br /> |
| * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to |
| * start at the index of the last search's match, thus not taking the whole input value into |
| * account. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="number-input-directive" module="numberExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('numberExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.example = { |
| value: 12 |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="ExampleController"> |
| <label>Number: |
| <input type="number" name="input" ng-model="example.value" |
| min="0" max="99" required> |
| </label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.number"> |
| Not valid number!</span> |
| </div> |
| <tt>value = {{example.value}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var value = element(by.binding('example.value')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('example.value')); |
| |
| it('should initialize to model', function() { |
| expect(value.getText()).toContain('12'); |
| expect(valid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| input.clear(); |
| input.sendKeys(''); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('false'); |
| }); |
| |
| it('should be invalid if over max', function() { |
| input.clear(); |
| input.sendKeys('123'); |
| expect(value.getText()).toEqual('value ='); |
| expect(valid.getText()).toContain('false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'number': numberInputType, |
| |
| |
| /** |
| * @ngdoc input |
| * @name input[url] |
| * |
| * @description |
| * Text input with URL validation. Sets the `url` validation error key if the content is not a |
| * valid URL. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** `input[url]` uses a regex to validate urls that is derived from the regex |
| * used in Chromium. If you need stricter validation, you can use `ng-pattern` or modify |
| * the built-in validators (see the {@link guide/forms Forms guide}) |
| * </div> |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than |
| * minlength. |
| * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than |
| * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of |
| * any length. |
| * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string |
| * that contains the regular expression body that will be converted to a regular expression |
| * as in the ngPattern directive. |
| * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match |
| * a RegExp found by evaluating the Angular expression given in the attribute value. |
| * If the expression evaluates to a RegExp object, then this is used directly. |
| * If the expression evaluates to a string, then it will be converted to a RegExp |
| * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to |
| * `new RegExp('^abc$')`.<br /> |
| * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to |
| * start at the index of the last search's match, thus not taking the whole input value into |
| * account. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="url-input-directive" module="urlExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('urlExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.url = { |
| text: 'http://google.com' |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="ExampleController"> |
| <label>URL: |
| <input type="url" name="input" ng-model="url.text" required> |
| <label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.url"> |
| Not valid url!</span> |
| </div> |
| <tt>text = {{url.text}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| <tt>myForm.$error.url = {{!!myForm.$error.url}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var text = element(by.binding('url.text')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('url.text')); |
| |
| it('should initialize to model', function() { |
| expect(text.getText()).toContain('http://google.com'); |
| expect(valid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| input.clear(); |
| input.sendKeys(''); |
| |
| expect(text.getText()).toEqual('text ='); |
| expect(valid.getText()).toContain('false'); |
| }); |
| |
| it('should be invalid if not url', function() { |
| input.clear(); |
| input.sendKeys('box'); |
| |
| expect(valid.getText()).toContain('false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'url': urlInputType, |
| |
| |
| /** |
| * @ngdoc input |
| * @name input[email] |
| * |
| * @description |
| * Text input with email validation. Sets the `email` validation error key if not a valid email |
| * address. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** `input[email]` uses a regex to validate email addresses that is derived from the regex |
| * used in Chromium. If you need stricter validation (e.g. requiring a top-level domain), you can |
| * use `ng-pattern` or modify the built-in validators (see the {@link guide/forms Forms guide}) |
| * </div> |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than |
| * minlength. |
| * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than |
| * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of |
| * any length. |
| * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string |
| * that contains the regular expression body that will be converted to a regular expression |
| * as in the ngPattern directive. |
| * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match |
| * a RegExp found by evaluating the Angular expression given in the attribute value. |
| * If the expression evaluates to a RegExp object, then this is used directly. |
| * If the expression evaluates to a string, then it will be converted to a RegExp |
| * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to |
| * `new RegExp('^abc$')`.<br /> |
| * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to |
| * start at the index of the last search's match, thus not taking the whole input value into |
| * account. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="email-input-directive" module="emailExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('emailExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.email = { |
| text: 'me@example.com' |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="ExampleController"> |
| <label>Email: |
| <input type="email" name="input" ng-model="email.text" required> |
| </label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.input.$error.required"> |
| Required!</span> |
| <span class="error" ng-show="myForm.input.$error.email"> |
| Not valid email!</span> |
| </div> |
| <tt>text = {{email.text}}</tt><br/> |
| <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/> |
| <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| <tt>myForm.$error.email = {{!!myForm.$error.email}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var text = element(by.binding('email.text')); |
| var valid = element(by.binding('myForm.input.$valid')); |
| var input = element(by.model('email.text')); |
| |
| it('should initialize to model', function() { |
| expect(text.getText()).toContain('me@example.com'); |
| expect(valid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if empty', function() { |
| input.clear(); |
| input.sendKeys(''); |
| expect(text.getText()).toEqual('text ='); |
| expect(valid.getText()).toContain('false'); |
| }); |
| |
| it('should be invalid if not email', function() { |
| input.clear(); |
| input.sendKeys('xxx'); |
| |
| expect(valid.getText()).toContain('false'); |
| }); |
| </file> |
| </example> |
| */ |
| 'email': emailInputType, |
| |
| |
| /** |
| * @ngdoc input |
| * @name input[radio] |
| * |
| * @description |
| * HTML radio button. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string} value The value to which the `ngModel` expression should be set when selected. |
| * Note that `value` only supports `string` values, i.e. the scope model needs to be a string, |
| * too. Use `ngValue` if you need complex models (`number`, `object`, ...). |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * @param {string} ngValue Angular expression to which `ngModel` will be be set when the radio |
| * is selected. Should be used instead of the `value` attribute if you need |
| * a non-string `ngModel` (`boolean`, `array`, ...). |
| * |
| * @example |
| <example name="radio-input-directive" module="radioExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('radioExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.color = { |
| name: 'blue' |
| }; |
| $scope.specialValue = { |
| "id": "12345", |
| "value": "green" |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="ExampleController"> |
| <label> |
| <input type="radio" ng-model="color.name" value="red"> |
| Red |
| </label><br/> |
| <label> |
| <input type="radio" ng-model="color.name" ng-value="specialValue"> |
| Green |
| </label><br/> |
| <label> |
| <input type="radio" ng-model="color.name" value="blue"> |
| Blue |
| </label><br/> |
| <tt>color = {{color.name | json}}</tt><br/> |
| </form> |
| Note that `ng-value="specialValue"` sets radio item's value to be the value of `$scope.specialValue`. |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should change state', function() { |
| var color = element(by.binding('color.name')); |
| |
| expect(color.getText()).toContain('blue'); |
| |
| element.all(by.model('color.name')).get(0).click(); |
| |
| expect(color.getText()).toContain('red'); |
| }); |
| </file> |
| </example> |
| */ |
| 'radio': radioInputType, |
| |
| |
| /** |
| * @ngdoc input |
| * @name input[checkbox] |
| * |
| * @description |
| * HTML checkbox. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {expression=} ngTrueValue The value to which the expression should be set when selected. |
| * @param {expression=} ngFalseValue The value to which the expression should be set when not selected. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * |
| * @example |
| <example name="checkbox-input-directive" module="checkboxExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('checkboxExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.checkboxModel = { |
| value1 : true, |
| value2 : 'YES' |
| }; |
| }]); |
| </script> |
| <form name="myForm" ng-controller="ExampleController"> |
| <label>Value1: |
| <input type="checkbox" ng-model="checkboxModel.value1"> |
| </label><br/> |
| <label>Value2: |
| <input type="checkbox" ng-model="checkboxModel.value2" |
| ng-true-value="'YES'" ng-false-value="'NO'"> |
| </label><br/> |
| <tt>value1 = {{checkboxModel.value1}}</tt><br/> |
| <tt>value2 = {{checkboxModel.value2}}</tt><br/> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should change state', function() { |
| var value1 = element(by.binding('checkboxModel.value1')); |
| var value2 = element(by.binding('checkboxModel.value2')); |
| |
| expect(value1.getText()).toContain('true'); |
| expect(value2.getText()).toContain('YES'); |
| |
| element(by.model('checkboxModel.value1')).click(); |
| element(by.model('checkboxModel.value2')).click(); |
| |
| expect(value1.getText()).toContain('false'); |
| expect(value2.getText()).toContain('NO'); |
| }); |
| </file> |
| </example> |
| */ |
| 'checkbox': checkboxInputType, |
| |
| 'hidden': noop, |
| 'button': noop, |
| 'submit': noop, |
| 'reset': noop, |
| 'file': noop |
| }; |
| |
| function stringBasedInputType(ctrl) { |
| ctrl.$formatters.push(function(value) { |
| return ctrl.$isEmpty(value) ? value : value.toString(); |
| }); |
| } |
| |
| function textInputType(scope, element, attr, ctrl, $sniffer, $browser) { |
| baseInputType(scope, element, attr, ctrl, $sniffer, $browser); |
| stringBasedInputType(ctrl); |
| } |
| |
| function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) { |
| var type = lowercase(element[0].type); |
| |
| // In composition mode, users are still inputing intermediate text buffer, |
| // hold the listener until composition is done. |
| // More about composition events: https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent |
| if (!$sniffer.android) { |
| var composing = false; |
| |
| element.on('compositionstart', function(data) { |
| composing = true; |
| }); |
| |
| element.on('compositionend', function() { |
| composing = false; |
| listener(); |
| }); |
| } |
| |
| var listener = function(ev) { |
| if (timeout) { |
| $browser.defer.cancel(timeout); |
| timeout = null; |
| } |
| if (composing) return; |
| var value = element.val(), |
| event = ev && ev.type; |
| |
| // By default we will trim the value |
| // If the attribute ng-trim exists we will avoid trimming |
| // If input type is 'password', the value is never trimmed |
| if (type !== 'password' && (!attr.ngTrim || attr.ngTrim !== 'false')) { |
| value = trim(value); |
| } |
| |
| // If a control is suffering from bad input (due to native validators), browsers discard its |
| // value, so it may be necessary to revalidate (by calling $setViewValue again) even if the |
| // control's value is the same empty value twice in a row. |
| if (ctrl.$viewValue !== value || (value === '' && ctrl.$$hasNativeValidators)) { |
| ctrl.$setViewValue(value, event); |
| } |
| }; |
| |
| // if the browser does support "input" event, we are fine - except on IE9 which doesn't fire the |
| // input event on backspace, delete or cut |
| if ($sniffer.hasEvent('input')) { |
| element.on('input', listener); |
| } else { |
| var timeout; |
| |
| var deferListener = function(ev, input, origValue) { |
| if (!timeout) { |
| timeout = $browser.defer(function() { |
| timeout = null; |
| if (!input || input.value !== origValue) { |
| listener(ev); |
| } |
| }); |
| } |
| }; |
| |
| element.on('keydown', function(event) { |
| var key = event.keyCode; |
| |
| // ignore |
| // command modifiers arrows |
| if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40)) return; |
| |
| deferListener(event, this, this.value); |
| }); |
| |
| // if user modifies input value using context menu in IE, we need "paste" and "cut" events to catch it |
| if ($sniffer.hasEvent('paste')) { |
| element.on('paste cut', deferListener); |
| } |
| } |
| |
| // if user paste into input using mouse on older browser |
| // or form autocomplete on newer browser, we need "change" event to catch it |
| element.on('change', listener); |
| |
| ctrl.$render = function() { |
| // Workaround for Firefox validation #12102. |
| var value = ctrl.$isEmpty(ctrl.$viewValue) ? '' : ctrl.$viewValue; |
| if (element.val() !== value) { |
| element.val(value); |
| } |
| }; |
| } |
| |
| function weekParser(isoWeek, existingDate) { |
| if (isDate(isoWeek)) { |
| return isoWeek; |
| } |
| |
| if (isString(isoWeek)) { |
| WEEK_REGEXP.lastIndex = 0; |
| var parts = WEEK_REGEXP.exec(isoWeek); |
| if (parts) { |
| var year = +parts[1], |
| week = +parts[2], |
| hours = 0, |
| minutes = 0, |
| seconds = 0, |
| milliseconds = 0, |
| firstThurs = getFirstThursdayOfYear(year), |
| addDays = (week - 1) * 7; |
| |
| if (existingDate) { |
| hours = existingDate.getHours(); |
| minutes = existingDate.getMinutes(); |
| seconds = existingDate.getSeconds(); |
| milliseconds = existingDate.getMilliseconds(); |
| } |
| |
| return new Date(year, 0, firstThurs.getDate() + addDays, hours, minutes, seconds, milliseconds); |
| } |
| } |
| |
| return NaN; |
| } |
| |
| function createDateParser(regexp, mapping) { |
| return function(iso, date) { |
| var parts, map; |
| |
| if (isDate(iso)) { |
| return iso; |
| } |
| |
| if (isString(iso)) { |
| // When a date is JSON'ified to wraps itself inside of an extra |
| // set of double quotes. This makes the date parsing code unable |
| // to match the date string and parse it as a date. |
| if (iso.charAt(0) == '"' && iso.charAt(iso.length - 1) == '"') { |
| iso = iso.substring(1, iso.length - 1); |
| } |
| if (ISO_DATE_REGEXP.test(iso)) { |
| return new Date(iso); |
| } |
| regexp.lastIndex = 0; |
| parts = regexp.exec(iso); |
| |
| if (parts) { |
| parts.shift(); |
| if (date) { |
| map = { |
| yyyy: date.getFullYear(), |
| MM: date.getMonth() + 1, |
| dd: date.getDate(), |
| HH: date.getHours(), |
| mm: date.getMinutes(), |
| ss: date.getSeconds(), |
| sss: date.getMilliseconds() / 1000 |
| }; |
| } else { |
| map = { yyyy: 1970, MM: 1, dd: 1, HH: 0, mm: 0, ss: 0, sss: 0 }; |
| } |
| |
| forEach(parts, function(part, index) { |
| if (index < mapping.length) { |
| map[mapping[index]] = +part; |
| } |
| }); |
| return new Date(map.yyyy, map.MM - 1, map.dd, map.HH, map.mm, map.ss || 0, map.sss * 1000 || 0); |
| } |
| } |
| |
| return NaN; |
| }; |
| } |
| |
| function createDateInputType(type, regexp, parseDate, format) { |
| return function dynamicDateInputType(scope, element, attr, ctrl, $sniffer, $browser, $filter) { |
| badInputChecker(scope, element, attr, ctrl); |
| baseInputType(scope, element, attr, ctrl, $sniffer, $browser); |
| var timezone = ctrl && ctrl.$options && ctrl.$options.timezone; |
| var previousDate; |
| |
| ctrl.$$parserName = type; |
| ctrl.$parsers.push(function(value) { |
| if (ctrl.$isEmpty(value)) return null; |
| if (regexp.test(value)) { |
| // Note: We cannot read ctrl.$modelValue, as there might be a different |
| // parser/formatter in the processing chain so that the model |
| // contains some different data format! |
| var parsedDate = parseDate(value, previousDate); |
| if (timezone) { |
| parsedDate = convertTimezoneToLocal(parsedDate, timezone); |
| } |
| return parsedDate; |
| } |
| return undefined; |
| }); |
| |
| ctrl.$formatters.push(function(value) { |
| if (value && !isDate(value)) { |
| throw ngModelMinErr('datefmt', 'Expected `{0}` to be a date', value); |
| } |
| if (isValidDate(value)) { |
| previousDate = value; |
| if (previousDate && timezone) { |
| previousDate = convertTimezoneToLocal(previousDate, timezone, true); |
| } |
| return $filter('date')(value, format, timezone); |
| } else { |
| previousDate = null; |
| return ''; |
| } |
| }); |
| |
| if (isDefined(attr.min) || attr.ngMin) { |
| var minVal; |
| ctrl.$validators.min = function(value) { |
| return !isValidDate(value) || isUndefined(minVal) || parseDate(value) >= minVal; |
| }; |
| attr.$observe('min', function(val) { |
| minVal = parseObservedDateValue(val); |
| ctrl.$validate(); |
| }); |
| } |
| |
| if (isDefined(attr.max) || attr.ngMax) { |
| var maxVal; |
| ctrl.$validators.max = function(value) { |
| return !isValidDate(value) || isUndefined(maxVal) || parseDate(value) <= maxVal; |
| }; |
| attr.$observe('max', function(val) { |
| maxVal = parseObservedDateValue(val); |
| ctrl.$validate(); |
| }); |
| } |
| |
| function isValidDate(value) { |
| // Invalid Date: getTime() returns NaN |
| return value && !(value.getTime && value.getTime() !== value.getTime()); |
| } |
| |
| function parseObservedDateValue(val) { |
| return isDefined(val) && !isDate(val) ? parseDate(val) || undefined : val; |
| } |
| }; |
| } |
| |
| function badInputChecker(scope, element, attr, ctrl) { |
| var node = element[0]; |
| var nativeValidation = ctrl.$$hasNativeValidators = isObject(node.validity); |
| if (nativeValidation) { |
| ctrl.$parsers.push(function(value) { |
| var validity = element.prop(VALIDITY_STATE_PROPERTY) || {}; |
| // Detect bug in FF35 for input[email] (https://bugzilla.mozilla.org/show_bug.cgi?id=1064430): |
| // - also sets validity.badInput (should only be validity.typeMismatch). |
| // - see http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#e-mail-state-(type=email) |
| // - can ignore this case as we can still read out the erroneous email... |
| return validity.badInput && !validity.typeMismatch ? undefined : value; |
| }); |
| } |
| } |
| |
| function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) { |
| badInputChecker(scope, element, attr, ctrl); |
| baseInputType(scope, element, attr, ctrl, $sniffer, $browser); |
| |
| ctrl.$$parserName = 'number'; |
| ctrl.$parsers.push(function(value) { |
| if (ctrl.$isEmpty(value)) return null; |
| if (NUMBER_REGEXP.test(value)) return parseFloat(value); |
| return undefined; |
| }); |
| |
| ctrl.$formatters.push(function(value) { |
| if (!ctrl.$isEmpty(value)) { |
| if (!isNumber(value)) { |
| throw ngModelMinErr('numfmt', 'Expected `{0}` to be a number', value); |
| } |
| value = value.toString(); |
| } |
| return value; |
| }); |
| |
| if (isDefined(attr.min) || attr.ngMin) { |
| var minVal; |
| ctrl.$validators.min = function(value) { |
| return ctrl.$isEmpty(value) || isUndefined(minVal) || value >= minVal; |
| }; |
| |
| attr.$observe('min', function(val) { |
| if (isDefined(val) && !isNumber(val)) { |
| val = parseFloat(val, 10); |
| } |
| minVal = isNumber(val) && !isNaN(val) ? val : undefined; |
| // TODO(matsko): implement validateLater to reduce number of validations |
| ctrl.$validate(); |
| }); |
| } |
| |
| if (isDefined(attr.max) || attr.ngMax) { |
| var maxVal; |
| ctrl.$validators.max = function(value) { |
| return ctrl.$isEmpty(value) || isUndefined(maxVal) || value <= maxVal; |
| }; |
| |
| attr.$observe('max', function(val) { |
| if (isDefined(val) && !isNumber(val)) { |
| val = parseFloat(val, 10); |
| } |
| maxVal = isNumber(val) && !isNaN(val) ? val : undefined; |
| // TODO(matsko): implement validateLater to reduce number of validations |
| ctrl.$validate(); |
| }); |
| } |
| } |
| |
| function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) { |
| // Note: no badInputChecker here by purpose as `url` is only a validation |
| // in browsers, i.e. we can always read out input.value even if it is not valid! |
| baseInputType(scope, element, attr, ctrl, $sniffer, $browser); |
| stringBasedInputType(ctrl); |
| |
| ctrl.$$parserName = 'url'; |
| ctrl.$validators.url = function(modelValue, viewValue) { |
| var value = modelValue || viewValue; |
| return ctrl.$isEmpty(value) || URL_REGEXP.test(value); |
| }; |
| } |
| |
| function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) { |
| // Note: no badInputChecker here by purpose as `url` is only a validation |
| // in browsers, i.e. we can always read out input.value even if it is not valid! |
| baseInputType(scope, element, attr, ctrl, $sniffer, $browser); |
| stringBasedInputType(ctrl); |
| |
| ctrl.$$parserName = 'email'; |
| ctrl.$validators.email = function(modelValue, viewValue) { |
| var value = modelValue || viewValue; |
| return ctrl.$isEmpty(value) || EMAIL_REGEXP.test(value); |
| }; |
| } |
| |
| function radioInputType(scope, element, attr, ctrl) { |
| // make the name unique, if not defined |
| if (isUndefined(attr.name)) { |
| element.attr('name', nextUid()); |
| } |
| |
| var listener = function(ev) { |
| if (element[0].checked) { |
| ctrl.$setViewValue(attr.value, ev && ev.type); |
| } |
| }; |
| |
| element.on('click', listener); |
| |
| ctrl.$render = function() { |
| var value = attr.value; |
| element[0].checked = (value == ctrl.$viewValue); |
| }; |
| |
| attr.$observe('value', ctrl.$render); |
| } |
| |
| function parseConstantExpr($parse, context, name, expression, fallback) { |
| var parseFn; |
| if (isDefined(expression)) { |
| parseFn = $parse(expression); |
| if (!parseFn.constant) { |
| throw ngModelMinErr('constexpr', 'Expected constant expression for `{0}`, but saw ' + |
| '`{1}`.', name, expression); |
| } |
| return parseFn(context); |
| } |
| return fallback; |
| } |
| |
| function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filter, $parse) { |
| var trueValue = parseConstantExpr($parse, scope, 'ngTrueValue', attr.ngTrueValue, true); |
| var falseValue = parseConstantExpr($parse, scope, 'ngFalseValue', attr.ngFalseValue, false); |
| |
| var listener = function(ev) { |
| ctrl.$setViewValue(element[0].checked, ev && ev.type); |
| }; |
| |
| element.on('click', listener); |
| |
| ctrl.$render = function() { |
| element[0].checked = ctrl.$viewValue; |
| }; |
| |
| // Override the standard `$isEmpty` because the $viewValue of an empty checkbox is always set to `false` |
| // This is because of the parser below, which compares the `$modelValue` with `trueValue` to convert |
| // it to a boolean. |
| ctrl.$isEmpty = function(value) { |
| return value === false; |
| }; |
| |
| ctrl.$formatters.push(function(value) { |
| return equals(value, trueValue); |
| }); |
| |
| ctrl.$parsers.push(function(value) { |
| return value ? trueValue : falseValue; |
| }); |
| } |
| |
| |
| /** |
| * @ngdoc directive |
| * @name textarea |
| * @restrict E |
| * |
| * @description |
| * HTML textarea element control with angular data-binding. The data-binding and validation |
| * properties of this element are exactly the same as those of the |
| * {@link ng.directive:input input element}. |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than |
| * minlength. |
| * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than |
| * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any |
| * length. |
| * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match |
| * a RegExp found by evaluating the Angular expression given in the attribute value. |
| * If the expression evaluates to a RegExp object, then this is used directly. |
| * If the expression evaluates to a string, then it will be converted to a RegExp |
| * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to |
| * `new RegExp('^abc$')`.<br /> |
| * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to |
| * start at the index of the last search's match, thus not taking the whole input value into |
| * account. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * @param {boolean=} [ngTrim=true] If set to false Angular will not automatically trim the input. |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name input |
| * @restrict E |
| * |
| * @description |
| * HTML input element control. When used together with {@link ngModel `ngModel`}, it provides data-binding, |
| * input state control, and validation. |
| * Input control follows HTML5 input types and polyfills the HTML5 validation behavior for older browsers. |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** Not every feature offered is available for all input types. |
| * Specifically, data binding and event handling via `ng-model` is unsupported for `input[file]`. |
| * </div> |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {boolean=} ngRequired Sets `required` attribute if set to true |
| * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than |
| * minlength. |
| * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than |
| * maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any |
| * length. |
| * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match |
| * a RegExp found by evaluating the Angular expression given in the attribute value. |
| * If the expression evaluates to a RegExp object, then this is used directly. |
| * If the expression evaluates to a string, then it will be converted to a RegExp |
| * after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to |
| * `new RegExp('^abc$')`.<br /> |
| * **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to |
| * start at the index of the last search's match, thus not taking the whole input value into |
| * account. |
| * @param {string=} ngChange Angular expression to be executed when input changes due to user |
| * interaction with the input element. |
| * @param {boolean=} [ngTrim=true] If set to false Angular will not automatically trim the input. |
| * This parameter is ignored for input[type=password] controls, which will never trim the |
| * input. |
| * |
| * @example |
| <example name="input-directive" module="inputExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('inputExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.user = {name: 'guest', last: 'visitor'}; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <form name="myForm"> |
| <label> |
| User name: |
| <input type="text" name="userName" ng-model="user.name" required> |
| </label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.userName.$error.required"> |
| Required!</span> |
| </div> |
| <label> |
| Last name: |
| <input type="text" name="lastName" ng-model="user.last" |
| ng-minlength="3" ng-maxlength="10"> |
| </label> |
| <div role="alert"> |
| <span class="error" ng-show="myForm.lastName.$error.minlength"> |
| Too short!</span> |
| <span class="error" ng-show="myForm.lastName.$error.maxlength"> |
| Too long!</span> |
| </div> |
| </form> |
| <hr> |
| <tt>user = {{user}}</tt><br/> |
| <tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br/> |
| <tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br/> |
| <tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br/> |
| <tt>myForm.lastName.$error = {{myForm.lastName.$error}}</tt><br/> |
| <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| <tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br/> |
| <tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br/> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var user = element(by.exactBinding('user')); |
| var userNameValid = element(by.binding('myForm.userName.$valid')); |
| var lastNameValid = element(by.binding('myForm.lastName.$valid')); |
| var lastNameError = element(by.binding('myForm.lastName.$error')); |
| var formValid = element(by.binding('myForm.$valid')); |
| var userNameInput = element(by.model('user.name')); |
| var userLastInput = element(by.model('user.last')); |
| |
| it('should initialize to model', function() { |
| expect(user.getText()).toContain('{"name":"guest","last":"visitor"}'); |
| expect(userNameValid.getText()).toContain('true'); |
| expect(formValid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if empty when required', function() { |
| userNameInput.clear(); |
| userNameInput.sendKeys(''); |
| |
| expect(user.getText()).toContain('{"last":"visitor"}'); |
| expect(userNameValid.getText()).toContain('false'); |
| expect(formValid.getText()).toContain('false'); |
| }); |
| |
| it('should be valid if empty when min length is set', function() { |
| userLastInput.clear(); |
| userLastInput.sendKeys(''); |
| |
| expect(user.getText()).toContain('{"name":"guest","last":""}'); |
| expect(lastNameValid.getText()).toContain('true'); |
| expect(formValid.getText()).toContain('true'); |
| }); |
| |
| it('should be invalid if less than required min length', function() { |
| userLastInput.clear(); |
| userLastInput.sendKeys('xx'); |
| |
| expect(user.getText()).toContain('{"name":"guest"}'); |
| expect(lastNameValid.getText()).toContain('false'); |
| expect(lastNameError.getText()).toContain('minlength'); |
| expect(formValid.getText()).toContain('false'); |
| }); |
| |
| it('should be invalid if longer than max length', function() { |
| userLastInput.clear(); |
| userLastInput.sendKeys('some ridiculously long name'); |
| |
| expect(user.getText()).toContain('{"name":"guest"}'); |
| expect(lastNameValid.getText()).toContain('false'); |
| expect(lastNameError.getText()).toContain('maxlength'); |
| expect(formValid.getText()).toContain('false'); |
| }); |
| </file> |
| </example> |
| */ |
| var inputDirective = ['$browser', '$sniffer', '$filter', '$parse', |
| function($browser, $sniffer, $filter, $parse) { |
| return { |
| restrict: 'E', |
| require: ['?ngModel'], |
| link: { |
| pre: function(scope, element, attr, ctrls) { |
| if (ctrls[0]) { |
| (inputType[lowercase(attr.type)] || inputType.text)(scope, element, attr, ctrls[0], $sniffer, |
| $browser, $filter, $parse); |
| } |
| } |
| } |
| }; |
| }]; |
| |
| |
| |
| var CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/; |
| /** |
| * @ngdoc directive |
| * @name ngValue |
| * |
| * @description |
| * Binds the given expression to the value of `<option>` or {@link input[radio] `input[radio]`}, |
| * so that when the element is selected, the {@link ngModel `ngModel`} of that element is set to |
| * the bound value. |
| * |
| * `ngValue` is useful when dynamically generating lists of radio buttons using |
| * {@link ngRepeat `ngRepeat`}, as shown below. |
| * |
| * Likewise, `ngValue` can be used to generate `<option>` elements for |
| * the {@link select `select`} element. In that case however, only strings are supported |
| * for the `value `attribute, so the resulting `ngModel` will always be a string. |
| * Support for `select` models with non-string values is available via `ngOptions`. |
| * |
| * @element input |
| * @param {string=} ngValue angular expression, whose value will be bound to the `value` attribute |
| * of the `input` element |
| * |
| * @example |
| <example name="ngValue-directive" module="valueExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('valueExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.names = ['pizza', 'unicorns', 'robots']; |
| $scope.my = { favorite: 'unicorns' }; |
| }]); |
| </script> |
| <form ng-controller="ExampleController"> |
| <h2>Which is your favorite?</h2> |
| <label ng-repeat="name in names" for="{{name}}"> |
| {{name}} |
| <input type="radio" |
| ng-model="my.favorite" |
| ng-value="name" |
| id="{{name}}" |
| name="favorite"> |
| </label> |
| <div>You chose {{my.favorite}}</div> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var favorite = element(by.binding('my.favorite')); |
| |
| it('should initialize to model', function() { |
| expect(favorite.getText()).toContain('unicorns'); |
| }); |
| it('should bind the values to the inputs', function() { |
| element.all(by.model('my.favorite')).get(0).click(); |
| expect(favorite.getText()).toContain('pizza'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngValueDirective = function() { |
| return { |
| restrict: 'A', |
| priority: 100, |
| compile: function(tpl, tplAttr) { |
| if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) { |
| return function ngValueConstantLink(scope, elm, attr) { |
| attr.$set('value', scope.$eval(attr.ngValue)); |
| }; |
| } else { |
| return function ngValueLink(scope, elm, attr) { |
| scope.$watch(attr.ngValue, function valueWatchAction(value) { |
| attr.$set('value', value); |
| }); |
| }; |
| } |
| } |
| }; |
| }; |
| |
| /** |
| * @ngdoc directive |
| * @name ngBind |
| * @restrict AC |
| * |
| * @description |
| * The `ngBind` attribute tells Angular to replace the text content of the specified HTML element |
| * with the value of a given expression, and to update the text content when the value of that |
| * expression changes. |
| * |
| * Typically, you don't use `ngBind` directly, but instead you use the double curly markup like |
| * `{{ expression }}` which is similar but less verbose. |
| * |
| * It is preferable to use `ngBind` instead of `{{ expression }}` if a template is momentarily |
| * displayed by the browser in its raw state before Angular compiles it. Since `ngBind` is an |
| * element attribute, it makes the bindings invisible to the user while the page is loading. |
| * |
| * An alternative solution to this problem would be using the |
| * {@link ng.directive:ngCloak ngCloak} directive. |
| * |
| * |
| * @element ANY |
| * @param {expression} ngBind {@link guide/expression Expression} to evaluate. |
| * |
| * @example |
| * Enter a name in the Live Preview text box; the greeting below the text box changes instantly. |
| <example module="bindExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('bindExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.name = 'Whirled'; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <label>Enter name: <input type="text" ng-model="name"></label><br> |
| Hello <span ng-bind="name"></span>! |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-bind', function() { |
| var nameInput = element(by.model('name')); |
| |
| expect(element(by.binding('name')).getText()).toBe('Whirled'); |
| nameInput.clear(); |
| nameInput.sendKeys('world'); |
| expect(element(by.binding('name')).getText()).toBe('world'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngBindDirective = ['$compile', function($compile) { |
| return { |
| restrict: 'AC', |
| compile: function ngBindCompile(templateElement) { |
| $compile.$$addBindingClass(templateElement); |
| return function ngBindLink(scope, element, attr) { |
| $compile.$$addBindingInfo(element, attr.ngBind); |
| element = element[0]; |
| scope.$watch(attr.ngBind, function ngBindWatchAction(value) { |
| element.textContent = isUndefined(value) ? '' : value; |
| }); |
| }; |
| } |
| }; |
| }]; |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngBindTemplate |
| * |
| * @description |
| * The `ngBindTemplate` directive specifies that the element |
| * text content should be replaced with the interpolation of the template |
| * in the `ngBindTemplate` attribute. |
| * Unlike `ngBind`, the `ngBindTemplate` can contain multiple `{{` `}}` |
| * expressions. This directive is needed since some HTML elements |
| * (such as TITLE and OPTION) cannot contain SPAN elements. |
| * |
| * @element ANY |
| * @param {string} ngBindTemplate template of form |
| * <tt>{{</tt> <tt>expression</tt> <tt>}}</tt> to eval. |
| * |
| * @example |
| * Try it here: enter text in text box and watch the greeting change. |
| <example module="bindExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('bindExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.salutation = 'Hello'; |
| $scope.name = 'World'; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <label>Salutation: <input type="text" ng-model="salutation"></label><br> |
| <label>Name: <input type="text" ng-model="name"></label><br> |
| <pre ng-bind-template="{{salutation}} {{name}}!"></pre> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-bind', function() { |
| var salutationElem = element(by.binding('salutation')); |
| var salutationInput = element(by.model('salutation')); |
| var nameInput = element(by.model('name')); |
| |
| expect(salutationElem.getText()).toBe('Hello World!'); |
| |
| salutationInput.clear(); |
| salutationInput.sendKeys('Greetings'); |
| nameInput.clear(); |
| nameInput.sendKeys('user'); |
| |
| expect(salutationElem.getText()).toBe('Greetings user!'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngBindTemplateDirective = ['$interpolate', '$compile', function($interpolate, $compile) { |
| return { |
| compile: function ngBindTemplateCompile(templateElement) { |
| $compile.$$addBindingClass(templateElement); |
| return function ngBindTemplateLink(scope, element, attr) { |
| var interpolateFn = $interpolate(element.attr(attr.$attr.ngBindTemplate)); |
| $compile.$$addBindingInfo(element, interpolateFn.expressions); |
| element = element[0]; |
| attr.$observe('ngBindTemplate', function(value) { |
| element.textContent = isUndefined(value) ? '' : value; |
| }); |
| }; |
| } |
| }; |
| }]; |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngBindHtml |
| * |
| * @description |
| * Evaluates the expression and inserts the resulting HTML into the element in a secure way. By default, |
| * the resulting HTML content will be sanitized using the {@link ngSanitize.$sanitize $sanitize} service. |
| * To utilize this functionality, ensure that `$sanitize` is available, for example, by including {@link |
| * ngSanitize} in your module's dependencies (not in core Angular). In order to use {@link ngSanitize} |
| * in your module's dependencies, you need to include "angular-sanitize.js" in your application. |
| * |
| * You may also bypass sanitization for values you know are safe. To do so, bind to |
| * an explicitly trusted value via {@link ng.$sce#trustAsHtml $sce.trustAsHtml}. See the example |
| * under {@link ng.$sce#show-me-an-example-using-sce- Strict Contextual Escaping (SCE)}. |
| * |
| * Note: If a `$sanitize` service is unavailable and the bound value isn't explicitly trusted, you |
| * will have an exception (instead of an exploit.) |
| * |
| * @element ANY |
| * @param {expression} ngBindHtml {@link guide/expression Expression} to evaluate. |
| * |
| * @example |
| |
| <example module="bindHtmlExample" deps="angular-sanitize.js"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <p ng-bind-html="myHTML"></p> |
| </div> |
| </file> |
| |
| <file name="script.js"> |
| angular.module('bindHtmlExample', ['ngSanitize']) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.myHTML = |
| 'I am an <code>HTML</code>string with ' + |
| '<a href="#">links!</a> and other <em>stuff</em>'; |
| }]); |
| </file> |
| |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-bind-html', function() { |
| expect(element(by.binding('myHTML')).getText()).toBe( |
| 'I am an HTMLstring with links! and other stuff'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngBindHtmlDirective = ['$sce', '$parse', '$compile', function($sce, $parse, $compile) { |
| return { |
| restrict: 'A', |
| compile: function ngBindHtmlCompile(tElement, tAttrs) { |
| var ngBindHtmlGetter = $parse(tAttrs.ngBindHtml); |
| var ngBindHtmlWatch = $parse(tAttrs.ngBindHtml, function getStringValue(value) { |
| return (value || '').toString(); |
| }); |
| $compile.$$addBindingClass(tElement); |
| |
| return function ngBindHtmlLink(scope, element, attr) { |
| $compile.$$addBindingInfo(element, attr.ngBindHtml); |
| |
| scope.$watch(ngBindHtmlWatch, function ngBindHtmlWatchAction() { |
| // we re-evaluate the expr because we want a TrustedValueHolderType |
| // for $sce, not a string |
| element.html($sce.getTrustedHtml(ngBindHtmlGetter(scope)) || ''); |
| }); |
| }; |
| } |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngChange |
| * |
| * @description |
| * Evaluate the given expression when the user changes the input. |
| * The expression is evaluated immediately, unlike the JavaScript onchange event |
| * which only triggers at the end of a change (usually, when the user leaves the |
| * form element or presses the return key). |
| * |
| * The `ngChange` expression is only evaluated when a change in the input value causes |
| * a new value to be committed to the model. |
| * |
| * It will not be evaluated: |
| * * if the value returned from the `$parsers` transformation pipeline has not changed |
| * * if the input has continued to be invalid since the model will stay `null` |
| * * if the model is changed programmatically and not by a change to the input value |
| * |
| * |
| * Note, this directive requires `ngModel` to be present. |
| * |
| * @element input |
| * @param {expression} ngChange {@link guide/expression Expression} to evaluate upon change |
| * in input value. |
| * |
| * @example |
| * <example name="ngChange-directive" module="changeExample"> |
| * <file name="index.html"> |
| * <script> |
| * angular.module('changeExample', []) |
| * .controller('ExampleController', ['$scope', function($scope) { |
| * $scope.counter = 0; |
| * $scope.change = function() { |
| * $scope.counter++; |
| * }; |
| * }]); |
| * </script> |
| * <div ng-controller="ExampleController"> |
| * <input type="checkbox" ng-model="confirmed" ng-change="change()" id="ng-change-example1" /> |
| * <input type="checkbox" ng-model="confirmed" id="ng-change-example2" /> |
| * <label for="ng-change-example2">Confirmed</label><br /> |
| * <tt>debug = {{confirmed}}</tt><br/> |
| * <tt>counter = {{counter}}</tt><br/> |
| * </div> |
| * </file> |
| * <file name="protractor.js" type="protractor"> |
| * var counter = element(by.binding('counter')); |
| * var debug = element(by.binding('confirmed')); |
| * |
| * it('should evaluate the expression if changing from view', function() { |
| * expect(counter.getText()).toContain('0'); |
| * |
| * element(by.id('ng-change-example1')).click(); |
| * |
| * expect(counter.getText()).toContain('1'); |
| * expect(debug.getText()).toContain('true'); |
| * }); |
| * |
| * it('should not evaluate the expression if changing from model', function() { |
| * element(by.id('ng-change-example2')).click(); |
| |
| * expect(counter.getText()).toContain('0'); |
| * expect(debug.getText()).toContain('true'); |
| * }); |
| * </file> |
| * </example> |
| */ |
| var ngChangeDirective = valueFn({ |
| restrict: 'A', |
| require: 'ngModel', |
| link: function(scope, element, attr, ctrl) { |
| ctrl.$viewChangeListeners.push(function() { |
| scope.$eval(attr.ngChange); |
| }); |
| } |
| }); |
| |
| function classDirective(name, selector) { |
| name = 'ngClass' + name; |
| return ['$animate', function($animate) { |
| return { |
| restrict: 'AC', |
| link: function(scope, element, attr) { |
| var oldVal; |
| |
| scope.$watch(attr[name], ngClassWatchAction, true); |
| |
| attr.$observe('class', function(value) { |
| ngClassWatchAction(scope.$eval(attr[name])); |
| }); |
| |
| |
| if (name !== 'ngClass') { |
| scope.$watch('$index', function($index, old$index) { |
| // jshint bitwise: false |
| var mod = $index & 1; |
| if (mod !== (old$index & 1)) { |
| var classes = arrayClasses(scope.$eval(attr[name])); |
| mod === selector ? |
| addClasses(classes) : |
| removeClasses(classes); |
| } |
| }); |
| } |
| |
| function addClasses(classes) { |
| var newClasses = digestClassCounts(classes, 1); |
| attr.$addClass(newClasses); |
| } |
| |
| function removeClasses(classes) { |
| var newClasses = digestClassCounts(classes, -1); |
| attr.$removeClass(newClasses); |
| } |
| |
| function digestClassCounts(classes, count) { |
| // Use createMap() to prevent class assumptions involving property |
| // names in Object.prototype |
| var classCounts = element.data('$classCounts') || createMap(); |
| var classesToUpdate = []; |
| forEach(classes, function(className) { |
| if (count > 0 || classCounts[className]) { |
| classCounts[className] = (classCounts[className] || 0) + count; |
| if (classCounts[className] === +(count > 0)) { |
| classesToUpdate.push(className); |
| } |
| } |
| }); |
| element.data('$classCounts', classCounts); |
| return classesToUpdate.join(' '); |
| } |
| |
| function updateClasses(oldClasses, newClasses) { |
| var toAdd = arrayDifference(newClasses, oldClasses); |
| var toRemove = arrayDifference(oldClasses, newClasses); |
| toAdd = digestClassCounts(toAdd, 1); |
| toRemove = digestClassCounts(toRemove, -1); |
| if (toAdd && toAdd.length) { |
| $animate.addClass(element, toAdd); |
| } |
| if (toRemove && toRemove.length) { |
| $animate.removeClass(element, toRemove); |
| } |
| } |
| |
| function ngClassWatchAction(newVal) { |
| if (selector === true || scope.$index % 2 === selector) { |
| var newClasses = arrayClasses(newVal || []); |
| if (!oldVal) { |
| addClasses(newClasses); |
| } else if (!equals(newVal,oldVal)) { |
| var oldClasses = arrayClasses(oldVal); |
| updateClasses(oldClasses, newClasses); |
| } |
| } |
| oldVal = shallowCopy(newVal); |
| } |
| } |
| }; |
| |
| function arrayDifference(tokens1, tokens2) { |
| var values = []; |
| |
| outer: |
| for (var i = 0; i < tokens1.length; i++) { |
| var token = tokens1[i]; |
| for (var j = 0; j < tokens2.length; j++) { |
| if (token == tokens2[j]) continue outer; |
| } |
| values.push(token); |
| } |
| return values; |
| } |
| |
| function arrayClasses(classVal) { |
| var classes = []; |
| if (isArray(classVal)) { |
| forEach(classVal, function(v) { |
| classes = classes.concat(arrayClasses(v)); |
| }); |
| return classes; |
| } else if (isString(classVal)) { |
| return classVal.split(' '); |
| } else if (isObject(classVal)) { |
| forEach(classVal, function(v, k) { |
| if (v) { |
| classes = classes.concat(k.split(' ')); |
| } |
| }); |
| return classes; |
| } |
| return classVal; |
| } |
| }]; |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name ngClass |
| * @restrict AC |
| * |
| * @description |
| * The `ngClass` directive allows you to dynamically set CSS classes on an HTML element by databinding |
| * an expression that represents all classes to be added. |
| * |
| * The directive operates in three different ways, depending on which of three types the expression |
| * evaluates to: |
| * |
| * 1. If the expression evaluates to a string, the string should be one or more space-delimited class |
| * names. |
| * |
| * 2. If the expression evaluates to an object, then for each key-value pair of the |
| * object with a truthy value the corresponding key is used as a class name. |
| * |
| * 3. If the expression evaluates to an array, each element of the array should either be a string as in |
| * type 1 or an object as in type 2. This means that you can mix strings and objects together in an array |
| * to give you more control over what CSS classes appear. See the code below for an example of this. |
| * |
| * |
| * The directive won't add duplicate classes if a particular class was already set. |
| * |
| * When the expression changes, the previously added classes are removed and only then are the |
| * new classes added. |
| * |
| * @animations |
| * **add** - happens just before the class is applied to the elements |
| * |
| * **remove** - happens just before the class is removed from the element |
| * |
| * @element ANY |
| * @param {expression} ngClass {@link guide/expression Expression} to eval. The result |
| * of the evaluation can be a string representing space delimited class |
| * names, an array, or a map of class names to boolean values. In the case of a map, the |
| * names of the properties whose values are truthy will be added as css classes to the |
| * element. |
| * |
| * @example Example that demonstrates basic bindings via ngClass directive. |
| <example> |
| <file name="index.html"> |
| <p ng-class="{strike: deleted, bold: important, 'has-error': error}">Map Syntax Example</p> |
| <label> |
| <input type="checkbox" ng-model="deleted"> |
| deleted (apply "strike" class) |
| </label><br> |
| <label> |
| <input type="checkbox" ng-model="important"> |
| important (apply "bold" class) |
| </label><br> |
| <label> |
| <input type="checkbox" ng-model="error"> |
| error (apply "has-error" class) |
| </label> |
| <hr> |
| <p ng-class="style">Using String Syntax</p> |
| <input type="text" ng-model="style" |
| placeholder="Type: bold strike red" aria-label="Type: bold strike red"> |
| <hr> |
| <p ng-class="[style1, style2, style3]">Using Array Syntax</p> |
| <input ng-model="style1" |
| placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red"><br> |
| <input ng-model="style2" |
| placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red 2"><br> |
| <input ng-model="style3" |
| placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red 3"><br> |
| <hr> |
| <p ng-class="[style4, {orange: warning}]">Using Array and Map Syntax</p> |
| <input ng-model="style4" placeholder="Type: bold, strike" aria-label="Type: bold, strike"><br> |
| <label><input type="checkbox" ng-model="warning"> warning (apply "orange" class)</label> |
| </file> |
| <file name="style.css"> |
| .strike { |
| text-decoration: line-through; |
| } |
| .bold { |
| font-weight: bold; |
| } |
| .red { |
| color: red; |
| } |
| .has-error { |
| color: red; |
| background-color: yellow; |
| } |
| .orange { |
| color: orange; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var ps = element.all(by.css('p')); |
| |
| it('should let you toggle the class', function() { |
| |
| expect(ps.first().getAttribute('class')).not.toMatch(/bold/); |
| expect(ps.first().getAttribute('class')).not.toMatch(/has-error/); |
| |
| element(by.model('important')).click(); |
| expect(ps.first().getAttribute('class')).toMatch(/bold/); |
| |
| element(by.model('error')).click(); |
| expect(ps.first().getAttribute('class')).toMatch(/has-error/); |
| }); |
| |
| it('should let you toggle string example', function() { |
| expect(ps.get(1).getAttribute('class')).toBe(''); |
| element(by.model('style')).clear(); |
| element(by.model('style')).sendKeys('red'); |
| expect(ps.get(1).getAttribute('class')).toBe('red'); |
| }); |
| |
| it('array example should have 3 classes', function() { |
| expect(ps.get(2).getAttribute('class')).toBe(''); |
| element(by.model('style1')).sendKeys('bold'); |
| element(by.model('style2')).sendKeys('strike'); |
| element(by.model('style3')).sendKeys('red'); |
| expect(ps.get(2).getAttribute('class')).toBe('bold strike red'); |
| }); |
| |
| it('array with map example should have 2 classes', function() { |
| expect(ps.last().getAttribute('class')).toBe(''); |
| element(by.model('style4')).sendKeys('bold'); |
| element(by.model('warning')).click(); |
| expect(ps.last().getAttribute('class')).toBe('bold orange'); |
| }); |
| </file> |
| </example> |
| |
| ## Animations |
| |
| The example below demonstrates how to perform animations using ngClass. |
| |
| <example module="ngAnimate" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| <input id="setbtn" type="button" value="set" ng-click="myVar='my-class'"> |
| <input id="clearbtn" type="button" value="clear" ng-click="myVar=''"> |
| <br> |
| <span class="base-class" ng-class="myVar">Sample Text</span> |
| </file> |
| <file name="style.css"> |
| .base-class { |
| transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s; |
| } |
| |
| .base-class.my-class { |
| color: red; |
| font-size:3em; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-class', function() { |
| expect(element(by.css('.base-class')).getAttribute('class')).not. |
| toMatch(/my-class/); |
| |
| element(by.id('setbtn')).click(); |
| |
| expect(element(by.css('.base-class')).getAttribute('class')). |
| toMatch(/my-class/); |
| |
| element(by.id('clearbtn')).click(); |
| |
| expect(element(by.css('.base-class')).getAttribute('class')).not. |
| toMatch(/my-class/); |
| }); |
| </file> |
| </example> |
| |
| |
| ## ngClass and pre-existing CSS3 Transitions/Animations |
| The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure. |
| Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder |
| any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure |
| to view the step by step details of {@link $animate#addClass $animate.addClass} and |
| {@link $animate#removeClass $animate.removeClass}. |
| */ |
| var ngClassDirective = classDirective('', true); |
| |
| /** |
| * @ngdoc directive |
| * @name ngClassOdd |
| * @restrict AC |
| * |
| * @description |
| * The `ngClassOdd` and `ngClassEven` directives work exactly as |
| * {@link ng.directive:ngClass ngClass}, except they work in |
| * conjunction with `ngRepeat` and take effect only on odd (even) rows. |
| * |
| * This directive can be applied only within the scope of an |
| * {@link ng.directive:ngRepeat ngRepeat}. |
| * |
| * @element ANY |
| * @param {expression} ngClassOdd {@link guide/expression Expression} to eval. The result |
| * of the evaluation can be a string representing space delimited class names or an array. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']"> |
| <li ng-repeat="name in names"> |
| <span ng-class-odd="'odd'" ng-class-even="'even'"> |
| {{name}} |
| </span> |
| </li> |
| </ol> |
| </file> |
| <file name="style.css"> |
| .odd { |
| color: red; |
| } |
| .even { |
| color: blue; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-class-odd and ng-class-even', function() { |
| expect(element(by.repeater('name in names').row(0).column('name')).getAttribute('class')). |
| toMatch(/odd/); |
| expect(element(by.repeater('name in names').row(1).column('name')).getAttribute('class')). |
| toMatch(/even/); |
| }); |
| </file> |
| </example> |
| */ |
| var ngClassOddDirective = classDirective('Odd', 0); |
| |
| /** |
| * @ngdoc directive |
| * @name ngClassEven |
| * @restrict AC |
| * |
| * @description |
| * The `ngClassOdd` and `ngClassEven` directives work exactly as |
| * {@link ng.directive:ngClass ngClass}, except they work in |
| * conjunction with `ngRepeat` and take effect only on odd (even) rows. |
| * |
| * This directive can be applied only within the scope of an |
| * {@link ng.directive:ngRepeat ngRepeat}. |
| * |
| * @element ANY |
| * @param {expression} ngClassEven {@link guide/expression Expression} to eval. The |
| * result of the evaluation can be a string representing space delimited class names or an array. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']"> |
| <li ng-repeat="name in names"> |
| <span ng-class-odd="'odd'" ng-class-even="'even'"> |
| {{name}} |
| </span> |
| </li> |
| </ol> |
| </file> |
| <file name="style.css"> |
| .odd { |
| color: red; |
| } |
| .even { |
| color: blue; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-class-odd and ng-class-even', function() { |
| expect(element(by.repeater('name in names').row(0).column('name')).getAttribute('class')). |
| toMatch(/odd/); |
| expect(element(by.repeater('name in names').row(1).column('name')).getAttribute('class')). |
| toMatch(/even/); |
| }); |
| </file> |
| </example> |
| */ |
| var ngClassEvenDirective = classDirective('Even', 1); |
| |
| /** |
| * @ngdoc directive |
| * @name ngCloak |
| * @restrict AC |
| * |
| * @description |
| * The `ngCloak` directive is used to prevent the Angular html template from being briefly |
| * displayed by the browser in its raw (uncompiled) form while your application is loading. Use this |
| * directive to avoid the undesirable flicker effect caused by the html template display. |
| * |
| * The directive can be applied to the `<body>` element, but the preferred usage is to apply |
| * multiple `ngCloak` directives to small portions of the page to permit progressive rendering |
| * of the browser view. |
| * |
| * `ngCloak` works in cooperation with the following css rule embedded within `angular.js` and |
| * `angular.min.js`. |
| * For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}). |
| * |
| * ```css |
| * [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak { |
| * display: none !important; |
| * } |
| * ``` |
| * |
| * When this css rule is loaded by the browser, all html elements (including their children) that |
| * are tagged with the `ngCloak` directive are hidden. When Angular encounters this directive |
| * during the compilation of the template it deletes the `ngCloak` element attribute, making |
| * the compiled element visible. |
| * |
| * For the best result, the `angular.js` script must be loaded in the head section of the html |
| * document; alternatively, the css rule above must be included in the external stylesheet of the |
| * application. |
| * |
| * @element ANY |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <div id="template1" ng-cloak>{{ 'hello' }}</div> |
| <div id="template2" class="ng-cloak">{{ 'world' }}</div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should remove the template directive and css class', function() { |
| expect($('#template1').getAttribute('ng-cloak')). |
| toBeNull(); |
| expect($('#template2').getAttribute('ng-cloak')). |
| toBeNull(); |
| }); |
| </file> |
| </example> |
| * |
| */ |
| var ngCloakDirective = ngDirective({ |
| compile: function(element, attr) { |
| attr.$set('ngCloak', undefined); |
| element.removeClass('ng-cloak'); |
| } |
| }); |
| |
| /** |
| * @ngdoc directive |
| * @name ngController |
| * |
| * @description |
| * The `ngController` directive attaches a controller class to the view. This is a key aspect of how angular |
| * supports the principles behind the Model-View-Controller design pattern. |
| * |
| * MVC components in angular: |
| * |
| * * Model — Models are the properties of a scope; scopes are attached to the DOM where scope properties |
| * are accessed through bindings. |
| * * View — The template (HTML with data bindings) that is rendered into the View. |
| * * Controller — The `ngController` directive specifies a Controller class; the class contains business |
| * logic behind the application to decorate the scope with functions and values |
| * |
| * Note that you can also attach controllers to the DOM by declaring it in a route definition |
| * via the {@link ngRoute.$route $route} service. A common mistake is to declare the controller |
| * again using `ng-controller` in the template itself. This will cause the controller to be attached |
| * and executed twice. |
| * |
| * @element ANY |
| * @scope |
| * @priority 500 |
| * @param {expression} ngController Name of a constructor function registered with the current |
| * {@link ng.$controllerProvider $controllerProvider} or an {@link guide/expression expression} |
| * that on the current scope evaluates to a constructor function. |
| * |
| * The controller instance can be published into a scope property by specifying |
| * `ng-controller="as propertyName"`. |
| * |
| * If the current `$controllerProvider` is configured to use globals (via |
| * {@link ng.$controllerProvider#allowGlobals `$controllerProvider.allowGlobals()` }), this may |
| * also be the name of a globally accessible constructor function (not recommended). |
| * |
| * @example |
| * Here is a simple form for editing user contact information. Adding, removing, clearing, and |
| * greeting are methods declared on the controller (see source tab). These methods can |
| * easily be called from the angular markup. Any changes to the data are automatically reflected |
| * in the View without the need for a manual update. |
| * |
| * Two different declaration styles are included below: |
| * |
| * * one binds methods and properties directly onto the controller using `this`: |
| * `ng-controller="SettingsController1 as settings"` |
| * * one injects `$scope` into the controller: |
| * `ng-controller="SettingsController2"` |
| * |
| * The second option is more common in the Angular community, and is generally used in boilerplates |
| * and in this guide. However, there are advantages to binding properties directly to the controller |
| * and avoiding scope. |
| * |
| * * Using `controller as` makes it obvious which controller you are accessing in the template when |
| * multiple controllers apply to an element. |
| * * If you are writing your controllers as classes you have easier access to the properties and |
| * methods, which will appear on the scope, from inside the controller code. |
| * * Since there is always a `.` in the bindings, you don't have to worry about prototypal |
| * inheritance masking primitives. |
| * |
| * This example demonstrates the `controller as` syntax. |
| * |
| * <example name="ngControllerAs" module="controllerAsExample"> |
| * <file name="index.html"> |
| * <div id="ctrl-as-exmpl" ng-controller="SettingsController1 as settings"> |
| * <label>Name: <input type="text" ng-model="settings.name"/></label> |
| * <button ng-click="settings.greet()">greet</button><br/> |
| * Contact: |
| * <ul> |
| * <li ng-repeat="contact in settings.contacts"> |
| * <select ng-model="contact.type" aria-label="Contact method" id="select_{{$index}}"> |
| * <option>phone</option> |
| * <option>email</option> |
| * </select> |
| * <input type="text" ng-model="contact.value" aria-labelledby="select_{{$index}}" /> |
| * <button ng-click="settings.clearContact(contact)">clear</button> |
| * <button ng-click="settings.removeContact(contact)" aria-label="Remove">X</button> |
| * </li> |
| * <li><button ng-click="settings.addContact()">add</button></li> |
| * </ul> |
| * </div> |
| * </file> |
| * <file name="app.js"> |
| * angular.module('controllerAsExample', []) |
| * .controller('SettingsController1', SettingsController1); |
| * |
| * function SettingsController1() { |
| * this.name = "John Smith"; |
| * this.contacts = [ |
| * {type: 'phone', value: '408 555 1212'}, |
| * {type: 'email', value: 'john.smith@example.org'} ]; |
| * } |
| * |
| * SettingsController1.prototype.greet = function() { |
| * alert(this.name); |
| * }; |
| * |
| * SettingsController1.prototype.addContact = function() { |
| * this.contacts.push({type: 'email', value: 'yourname@example.org'}); |
| * }; |
| * |
| * SettingsController1.prototype.removeContact = function(contactToRemove) { |
| * var index = this.contacts.indexOf(contactToRemove); |
| * this.contacts.splice(index, 1); |
| * }; |
| * |
| * SettingsController1.prototype.clearContact = function(contact) { |
| * contact.type = 'phone'; |
| * contact.value = ''; |
| * }; |
| * </file> |
| * <file name="protractor.js" type="protractor"> |
| * it('should check controller as', function() { |
| * var container = element(by.id('ctrl-as-exmpl')); |
| * expect(container.element(by.model('settings.name')) |
| * .getAttribute('value')).toBe('John Smith'); |
| * |
| * var firstRepeat = |
| * container.element(by.repeater('contact in settings.contacts').row(0)); |
| * var secondRepeat = |
| * container.element(by.repeater('contact in settings.contacts').row(1)); |
| * |
| * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) |
| * .toBe('408 555 1212'); |
| * |
| * expect(secondRepeat.element(by.model('contact.value')).getAttribute('value')) |
| * .toBe('john.smith@example.org'); |
| * |
| * firstRepeat.element(by.buttonText('clear')).click(); |
| * |
| * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) |
| * .toBe(''); |
| * |
| * container.element(by.buttonText('add')).click(); |
| * |
| * expect(container.element(by.repeater('contact in settings.contacts').row(2)) |
| * .element(by.model('contact.value')) |
| * .getAttribute('value')) |
| * .toBe('yourname@example.org'); |
| * }); |
| * </file> |
| * </example> |
| * |
| * This example demonstrates the "attach to `$scope`" style of controller. |
| * |
| * <example name="ngController" module="controllerExample"> |
| * <file name="index.html"> |
| * <div id="ctrl-exmpl" ng-controller="SettingsController2"> |
| * <label>Name: <input type="text" ng-model="name"/></label> |
| * <button ng-click="greet()">greet</button><br/> |
| * Contact: |
| * <ul> |
| * <li ng-repeat="contact in contacts"> |
| * <select ng-model="contact.type" id="select_{{$index}}"> |
| * <option>phone</option> |
| * <option>email</option> |
| * </select> |
| * <input type="text" ng-model="contact.value" aria-labelledby="select_{{$index}}" /> |
| * <button ng-click="clearContact(contact)">clear</button> |
| * <button ng-click="removeContact(contact)">X</button> |
| * </li> |
| * <li>[ <button ng-click="addContact()">add</button> ]</li> |
| * </ul> |
| * </div> |
| * </file> |
| * <file name="app.js"> |
| * angular.module('controllerExample', []) |
| * .controller('SettingsController2', ['$scope', SettingsController2]); |
| * |
| * function SettingsController2($scope) { |
| * $scope.name = "John Smith"; |
| * $scope.contacts = [ |
| * {type:'phone', value:'408 555 1212'}, |
| * {type:'email', value:'john.smith@example.org'} ]; |
| * |
| * $scope.greet = function() { |
| * alert($scope.name); |
| * }; |
| * |
| * $scope.addContact = function() { |
| * $scope.contacts.push({type:'email', value:'yourname@example.org'}); |
| * }; |
| * |
| * $scope.removeContact = function(contactToRemove) { |
| * var index = $scope.contacts.indexOf(contactToRemove); |
| * $scope.contacts.splice(index, 1); |
| * }; |
| * |
| * $scope.clearContact = function(contact) { |
| * contact.type = 'phone'; |
| * contact.value = ''; |
| * }; |
| * } |
| * </file> |
| * <file name="protractor.js" type="protractor"> |
| * it('should check controller', function() { |
| * var container = element(by.id('ctrl-exmpl')); |
| * |
| * expect(container.element(by.model('name')) |
| * .getAttribute('value')).toBe('John Smith'); |
| * |
| * var firstRepeat = |
| * container.element(by.repeater('contact in contacts').row(0)); |
| * var secondRepeat = |
| * container.element(by.repeater('contact in contacts').row(1)); |
| * |
| * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) |
| * .toBe('408 555 1212'); |
| * expect(secondRepeat.element(by.model('contact.value')).getAttribute('value')) |
| * .toBe('john.smith@example.org'); |
| * |
| * firstRepeat.element(by.buttonText('clear')).click(); |
| * |
| * expect(firstRepeat.element(by.model('contact.value')).getAttribute('value')) |
| * .toBe(''); |
| * |
| * container.element(by.buttonText('add')).click(); |
| * |
| * expect(container.element(by.repeater('contact in contacts').row(2)) |
| * .element(by.model('contact.value')) |
| * .getAttribute('value')) |
| * .toBe('yourname@example.org'); |
| * }); |
| * </file> |
| *</example> |
| |
| */ |
| var ngControllerDirective = [function() { |
| return { |
| restrict: 'A', |
| scope: true, |
| controller: '@', |
| priority: 500 |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngCsp |
| * |
| * @element html |
| * @description |
| * |
| * Angular has some features that can break certain |
| * [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) rules. |
| * |
| * If you intend to implement these rules then you must tell Angular not to use these features. |
| * |
| * This is necessary when developing things like Google Chrome Extensions or Universal Windows Apps. |
| * |
| * |
| * The following rules affect Angular: |
| * |
| * * `unsafe-eval`: this rule forbids apps to use `eval` or `Function(string)` generated functions |
| * (among other things). Angular makes use of this in the {@link $parse} service to provide a 30% |
| * increase in the speed of evaluating Angular expressions. |
| * |
| * * `unsafe-inline`: this rule forbids apps from inject custom styles into the document. Angular |
| * makes use of this to include some CSS rules (e.g. {@link ngCloak} and {@link ngHide}). |
| * To make these directives work when a CSP rule is blocking inline styles, you must link to the |
| * `angular-csp.css` in your HTML manually. |
| * |
| * If you do not provide `ngCsp` then Angular tries to autodetect if CSP is blocking unsafe-eval |
| * and automatically deactivates this feature in the {@link $parse} service. This autodetection, |
| * however, triggers a CSP error to be logged in the console: |
| * |
| * ``` |
| * Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of |
| * script in the following Content Security Policy directive: "default-src 'self'". Note that |
| * 'script-src' was not explicitly set, so 'default-src' is used as a fallback. |
| * ``` |
| * |
| * This error is harmless but annoying. To prevent the error from showing up, put the `ngCsp` |
| * directive on an element of the HTML document that appears before the `<script>` tag that loads |
| * the `angular.js` file. |
| * |
| * *Note: This directive is only available in the `ng-csp` and `data-ng-csp` attribute form.* |
| * |
| * You can specify which of the CSP related Angular features should be deactivated by providing |
| * a value for the `ng-csp` attribute. The options are as follows: |
| * |
| * * no-inline-style: this stops Angular from injecting CSS styles into the DOM |
| * |
| * * no-unsafe-eval: this stops Angular from optimising $parse with unsafe eval of strings |
| * |
| * You can use these values in the following combinations: |
| * |
| * |
| * * No declaration means that Angular will assume that you can do inline styles, but it will do |
| * a runtime check for unsafe-eval. E.g. `<body>`. This is backwardly compatible with previous versions |
| * of Angular. |
| * |
| * * A simple `ng-csp` (or `data-ng-csp`) attribute will tell Angular to deactivate both inline |
| * styles and unsafe eval. E.g. `<body ng-csp>`. This is backwardly compatible with previous versions |
| * of Angular. |
| * |
| * * Specifying only `no-unsafe-eval` tells Angular that we must not use eval, but that we can inject |
| * inline styles. E.g. `<body ng-csp="no-unsafe-eval">`. |
| * |
| * * Specifying only `no-inline-style` tells Angular that we must not inject styles, but that we can |
| * run eval - no automcatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">` |
| * |
| * * Specifying both `no-unsafe-eval` and `no-inline-style` tells Angular that we must not inject |
| * styles nor use eval, which is the same as an empty: ng-csp. |
| * E.g.`<body ng-csp="no-inline-style;no-unsafe-eval">` |
| * |
| * @example |
| * This example shows how to apply the `ngCsp` directive to the `html` tag. |
| ```html |
| <!doctype html> |
| <html ng-app ng-csp> |
| ... |
| ... |
| </html> |
| ``` |
| * @example |
| // Note: the suffix `.csp` in the example name triggers |
| // csp mode in our http server! |
| <example name="example.csp" module="cspExample" ng-csp="true"> |
| <file name="index.html"> |
| <div ng-controller="MainController as ctrl"> |
| <div> |
| <button ng-click="ctrl.inc()" id="inc">Increment</button> |
| <span id="counter"> |
| {{ctrl.counter}} |
| </span> |
| </div> |
| |
| <div> |
| <button ng-click="ctrl.evil()" id="evil">Evil</button> |
| <span id="evilError"> |
| {{ctrl.evilError}} |
| </span> |
| </div> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('cspExample', []) |
| .controller('MainController', function() { |
| this.counter = 0; |
| this.inc = function() { |
| this.counter++; |
| }; |
| this.evil = function() { |
| // jshint evil:true |
| try { |
| eval('1+2'); |
| } catch (e) { |
| this.evilError = e.message; |
| } |
| }; |
| }); |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var util, webdriver; |
| |
| var incBtn = element(by.id('inc')); |
| var counter = element(by.id('counter')); |
| var evilBtn = element(by.id('evil')); |
| var evilError = element(by.id('evilError')); |
| |
| function getAndClearSevereErrors() { |
| return browser.manage().logs().get('browser').then(function(browserLog) { |
| return browserLog.filter(function(logEntry) { |
| return logEntry.level.value > webdriver.logging.Level.WARNING.value; |
| }); |
| }); |
| } |
| |
| function clearErrors() { |
| getAndClearSevereErrors(); |
| } |
| |
| function expectNoErrors() { |
| getAndClearSevereErrors().then(function(filteredLog) { |
| expect(filteredLog.length).toEqual(0); |
| if (filteredLog.length) { |
| console.log('browser console errors: ' + util.inspect(filteredLog)); |
| } |
| }); |
| } |
| |
| function expectError(regex) { |
| getAndClearSevereErrors().then(function(filteredLog) { |
| var found = false; |
| filteredLog.forEach(function(log) { |
| if (log.message.match(regex)) { |
| found = true; |
| } |
| }); |
| if (!found) { |
| throw new Error('expected an error that matches ' + regex); |
| } |
| }); |
| } |
| |
| beforeEach(function() { |
| util = require('util'); |
| webdriver = require('protractor/node_modules/selenium-webdriver'); |
| }); |
| |
| // For now, we only test on Chrome, |
| // as Safari does not load the page with Protractor's injected scripts, |
| // and Firefox webdriver always disables content security policy (#6358) |
| if (browser.params.browser !== 'chrome') { |
| return; |
| } |
| |
| it('should not report errors when the page is loaded', function() { |
| // clear errors so we are not dependent on previous tests |
| clearErrors(); |
| // Need to reload the page as the page is already loaded when |
| // we come here |
| browser.driver.getCurrentUrl().then(function(url) { |
| browser.get(url); |
| }); |
| expectNoErrors(); |
| }); |
| |
| it('should evaluate expressions', function() { |
| expect(counter.getText()).toEqual('0'); |
| incBtn.click(); |
| expect(counter.getText()).toEqual('1'); |
| expectNoErrors(); |
| }); |
| |
| it('should throw and report an error when using "eval"', function() { |
| evilBtn.click(); |
| expect(evilError.getText()).toMatch(/Content Security Policy/); |
| expectError(/Content Security Policy/); |
| }); |
| </file> |
| </example> |
| */ |
| |
| // ngCsp is not implemented as a proper directive any more, because we need it be processed while we |
| // bootstrap the system (before $parse is instantiated), for this reason we just have |
| // the csp() fn that looks for the `ng-csp` attribute anywhere in the current doc |
| |
| /** |
| * @ngdoc directive |
| * @name ngClick |
| * |
| * @description |
| * The ngClick directive allows you to specify custom behavior when |
| * an element is clicked. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngClick {@link guide/expression Expression} to evaluate upon |
| * click. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-click="count = count + 1" ng-init="count=0"> |
| Increment |
| </button> |
| <span> |
| count: {{count}} |
| </span> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-click', function() { |
| expect(element(by.binding('count')).getText()).toMatch('0'); |
| element(by.css('button')).click(); |
| expect(element(by.binding('count')).getText()).toMatch('1'); |
| }); |
| </file> |
| </example> |
| */ |
| /* |
| * A collection of directives that allows creation of custom event handlers that are defined as |
| * angular expressions and are compiled and executed within the current scope. |
| */ |
| var ngEventDirectives = {}; |
| |
| // For events that might fire synchronously during DOM manipulation |
| // we need to execute their event handlers asynchronously using $evalAsync, |
| // so that they are not executed in an inconsistent state. |
| var forceAsyncEvents = { |
| 'blur': true, |
| 'focus': true |
| }; |
| forEach( |
| 'click dblclick mousedown mouseup mouseover mouseout mousemove mouseenter mouseleave keydown keyup keypress submit focus blur copy cut paste'.split(' '), |
| function(eventName) { |
| var directiveName = directiveNormalize('ng-' + eventName); |
| ngEventDirectives[directiveName] = ['$parse', '$rootScope', function($parse, $rootScope) { |
| return { |
| restrict: 'A', |
| compile: function($element, attr) { |
| // We expose the powerful $event object on the scope that provides access to the Window, |
| // etc. that isn't protected by the fast paths in $parse. We explicitly request better |
| // checks at the cost of speed since event handler expressions are not executed as |
| // frequently as regular change detection. |
| var fn = $parse(attr[directiveName], /* interceptorFn */ null, /* expensiveChecks */ true); |
| return function ngEventHandler(scope, element) { |
| element.on(eventName, function(event) { |
| var callback = function() { |
| fn(scope, {$event:event}); |
| }; |
| if (forceAsyncEvents[eventName] && $rootScope.$$phase) { |
| scope.$evalAsync(callback); |
| } else { |
| scope.$apply(callback); |
| } |
| }); |
| }; |
| } |
| }; |
| }]; |
| } |
| ); |
| |
| /** |
| * @ngdoc directive |
| * @name ngDblclick |
| * |
| * @description |
| * The `ngDblclick` directive allows you to specify custom behavior on a dblclick event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngDblclick {@link guide/expression Expression} to evaluate upon |
| * a dblclick. (The Event object is available as `$event`) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-dblclick="count = count + 1" ng-init="count=0"> |
| Increment (on double click) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngMousedown |
| * |
| * @description |
| * The ngMousedown directive allows you to specify custom behavior on mousedown event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngMousedown {@link guide/expression Expression} to evaluate upon |
| * mousedown. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-mousedown="count = count + 1" ng-init="count=0"> |
| Increment (on mouse down) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngMouseup |
| * |
| * @description |
| * Specify custom behavior on mouseup event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngMouseup {@link guide/expression Expression} to evaluate upon |
| * mouseup. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-mouseup="count = count + 1" ng-init="count=0"> |
| Increment (on mouse up) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngMouseover |
| * |
| * @description |
| * Specify custom behavior on mouseover event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngMouseover {@link guide/expression Expression} to evaluate upon |
| * mouseover. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-mouseover="count = count + 1" ng-init="count=0"> |
| Increment (when mouse is over) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngMouseenter |
| * |
| * @description |
| * Specify custom behavior on mouseenter event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngMouseenter {@link guide/expression Expression} to evaluate upon |
| * mouseenter. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-mouseenter="count = count + 1" ng-init="count=0"> |
| Increment (when mouse enters) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngMouseleave |
| * |
| * @description |
| * Specify custom behavior on mouseleave event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngMouseleave {@link guide/expression Expression} to evaluate upon |
| * mouseleave. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-mouseleave="count = count + 1" ng-init="count=0"> |
| Increment (when mouse leaves) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngMousemove |
| * |
| * @description |
| * Specify custom behavior on mousemove event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngMousemove {@link guide/expression Expression} to evaluate upon |
| * mousemove. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <button ng-mousemove="count = count + 1" ng-init="count=0"> |
| Increment (when mouse moves) |
| </button> |
| count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngKeydown |
| * |
| * @description |
| * Specify custom behavior on keydown event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngKeydown {@link guide/expression Expression} to evaluate upon |
| * keydown. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <input ng-keydown="count = count + 1" ng-init="count=0"> |
| key down count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngKeyup |
| * |
| * @description |
| * Specify custom behavior on keyup event. |
| * |
| * @element ANY |
| * @priority 0 |
| * @param {expression} ngKeyup {@link guide/expression Expression} to evaluate upon |
| * keyup. (Event object is available as `$event` and can be interrogated for keyCode, altKey, etc.) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <p>Typing in the input box below updates the key count</p> |
| <input ng-keyup="count = count + 1" ng-init="count=0"> key up count: {{count}} |
| |
| <p>Typing in the input box below updates the keycode</p> |
| <input ng-keyup="event=$event"> |
| <p>event keyCode: {{ event.keyCode }}</p> |
| <p>event altKey: {{ event.altKey }}</p> |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngKeypress |
| * |
| * @description |
| * Specify custom behavior on keypress event. |
| * |
| * @element ANY |
| * @param {expression} ngKeypress {@link guide/expression Expression} to evaluate upon |
| * keypress. ({@link guide/expression#-event- Event object is available as `$event`} |
| * and can be interrogated for keyCode, altKey, etc.) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <input ng-keypress="count = count + 1" ng-init="count=0"> |
| key press count: {{count}} |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngSubmit |
| * |
| * @description |
| * Enables binding angular expressions to onsubmit events. |
| * |
| * Additionally it prevents the default action (which for form means sending the request to the |
| * server and reloading the current page), but only if the form does not contain `action`, |
| * `data-action`, or `x-action` attributes. |
| * |
| * <div class="alert alert-warning"> |
| * **Warning:** Be careful not to cause "double-submission" by using both the `ngClick` and |
| * `ngSubmit` handlers together. See the |
| * {@link form#submitting-a-form-and-preventing-the-default-action `form` directive documentation} |
| * for a detailed discussion of when `ngSubmit` may be triggered. |
| * </div> |
| * |
| * @element form |
| * @priority 0 |
| * @param {expression} ngSubmit {@link guide/expression Expression} to eval. |
| * ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example module="submitExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('submitExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.list = []; |
| $scope.text = 'hello'; |
| $scope.submit = function() { |
| if ($scope.text) { |
| $scope.list.push(this.text); |
| $scope.text = ''; |
| } |
| }; |
| }]); |
| </script> |
| <form ng-submit="submit()" ng-controller="ExampleController"> |
| Enter text and hit enter: |
| <input type="text" ng-model="text" name="text" /> |
| <input type="submit" id="submit" value="Submit" /> |
| <pre>list={{list}}</pre> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-submit', function() { |
| expect(element(by.binding('list')).getText()).toBe('list=[]'); |
| element(by.css('#submit')).click(); |
| expect(element(by.binding('list')).getText()).toContain('hello'); |
| expect(element(by.model('text')).getAttribute('value')).toBe(''); |
| }); |
| it('should ignore empty strings', function() { |
| expect(element(by.binding('list')).getText()).toBe('list=[]'); |
| element(by.css('#submit')).click(); |
| element(by.css('#submit')).click(); |
| expect(element(by.binding('list')).getText()).toContain('hello'); |
| }); |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngFocus |
| * |
| * @description |
| * Specify custom behavior on focus event. |
| * |
| * Note: As the `focus` event is executed synchronously when calling `input.focus()` |
| * AngularJS executes the expression using `scope.$evalAsync` if the event is fired |
| * during an `$apply` to ensure a consistent state. |
| * |
| * @element window, input, select, textarea, a |
| * @priority 0 |
| * @param {expression} ngFocus {@link guide/expression Expression} to evaluate upon |
| * focus. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| * See {@link ng.directive:ngClick ngClick} |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngBlur |
| * |
| * @description |
| * Specify custom behavior on blur event. |
| * |
| * A [blur event](https://developer.mozilla.org/en-US/docs/Web/Events/blur) fires when |
| * an element has lost focus. |
| * |
| * Note: As the `blur` event is executed synchronously also during DOM manipulations |
| * (e.g. removing a focussed input), |
| * AngularJS executes the expression using `scope.$evalAsync` if the event is fired |
| * during an `$apply` to ensure a consistent state. |
| * |
| * @element window, input, select, textarea, a |
| * @priority 0 |
| * @param {expression} ngBlur {@link guide/expression Expression} to evaluate upon |
| * blur. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| * See {@link ng.directive:ngClick ngClick} |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngCopy |
| * |
| * @description |
| * Specify custom behavior on copy event. |
| * |
| * @element window, input, select, textarea, a |
| * @priority 0 |
| * @param {expression} ngCopy {@link guide/expression Expression} to evaluate upon |
| * copy. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <input ng-copy="copied=true" ng-init="copied=false; value='copy me'" ng-model="value"> |
| copied: {{copied}} |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngCut |
| * |
| * @description |
| * Specify custom behavior on cut event. |
| * |
| * @element window, input, select, textarea, a |
| * @priority 0 |
| * @param {expression} ngCut {@link guide/expression Expression} to evaluate upon |
| * cut. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <input ng-cut="cut=true" ng-init="cut=false; value='cut me'" ng-model="value"> |
| cut: {{cut}} |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngPaste |
| * |
| * @description |
| * Specify custom behavior on paste event. |
| * |
| * @element window, input, select, textarea, a |
| * @priority 0 |
| * @param {expression} ngPaste {@link guide/expression Expression} to evaluate upon |
| * paste. ({@link guide/expression#-event- Event object is available as `$event`}) |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <input ng-paste="paste=true" ng-init="paste=false" placeholder='paste here'> |
| pasted: {{paste}} |
| </file> |
| </example> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ngIf |
| * @restrict A |
| * @multiElement |
| * |
| * @description |
| * The `ngIf` directive removes or recreates a portion of the DOM tree based on an |
| * {expression}. If the expression assigned to `ngIf` evaluates to a false |
| * value then the element is removed from the DOM, otherwise a clone of the |
| * element is reinserted into the DOM. |
| * |
| * `ngIf` differs from `ngShow` and `ngHide` in that `ngIf` completely removes and recreates the |
| * element in the DOM rather than changing its visibility via the `display` css property. A common |
| * case when this difference is significant is when using css selectors that rely on an element's |
| * position within the DOM, such as the `:first-child` or `:last-child` pseudo-classes. |
| * |
| * Note that when an element is removed using `ngIf` its scope is destroyed and a new scope |
| * is created when the element is restored. The scope created within `ngIf` inherits from |
| * its parent scope using |
| * [prototypal inheritance](https://github.com/angular/angular.js/wiki/Understanding-Scopes#javascript-prototypal-inheritance). |
| * An important implication of this is if `ngModel` is used within `ngIf` to bind to |
| * a javascript primitive defined in the parent scope. In this case any modifications made to the |
| * variable within the child scope will override (hide) the value in the parent scope. |
| * |
| * Also, `ngIf` recreates elements using their compiled state. An example of this behavior |
| * is if an element's class attribute is directly modified after it's compiled, using something like |
| * jQuery's `.addClass()` method, and the element is later removed. When `ngIf` recreates the element |
| * the added class will be lost because the original compiled state is used to regenerate the element. |
| * |
| * Additionally, you can provide animations via the `ngAnimate` module to animate the `enter` |
| * and `leave` effects. |
| * |
| * @animations |
| * enter - happens just after the `ngIf` contents change and a new DOM element is created and injected into the `ngIf` container |
| * leave - happens just before the `ngIf` contents are removed from the DOM |
| * |
| * @element ANY |
| * @scope |
| * @priority 600 |
| * @param {expression} ngIf If the {@link guide/expression expression} is falsy then |
| * the element is removed from the DOM tree. If it is truthy a copy of the compiled |
| * element is added to the DOM tree. |
| * |
| * @example |
| <example module="ngAnimate" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| <label>Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /></label><br/> |
| Show when checked: |
| <span ng-if="checked" class="animate-if"> |
| This is removed when the checkbox is unchecked. |
| </span> |
| </file> |
| <file name="animations.css"> |
| .animate-if { |
| background:white; |
| border:1px solid black; |
| padding:10px; |
| } |
| |
| .animate-if.ng-enter, .animate-if.ng-leave { |
| transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s; |
| } |
| |
| .animate-if.ng-enter, |
| .animate-if.ng-leave.ng-leave-active { |
| opacity:0; |
| } |
| |
| .animate-if.ng-leave, |
| .animate-if.ng-enter.ng-enter-active { |
| opacity:1; |
| } |
| </file> |
| </example> |
| */ |
| var ngIfDirective = ['$animate', function($animate) { |
| return { |
| multiElement: true, |
| transclude: 'element', |
| priority: 600, |
| terminal: true, |
| restrict: 'A', |
| $$tlb: true, |
| link: function($scope, $element, $attr, ctrl, $transclude) { |
| var block, childScope, previousElements; |
| $scope.$watch($attr.ngIf, function ngIfWatchAction(value) { |
| |
| if (value) { |
| if (!childScope) { |
| $transclude(function(clone, newScope) { |
| childScope = newScope; |
| clone[clone.length++] = document.createComment(' end ngIf: ' + $attr.ngIf + ' '); |
| // Note: We only need the first/last node of the cloned nodes. |
| // However, we need to keep the reference to the jqlite wrapper as it might be changed later |
| // by a directive with templateUrl when its template arrives. |
| block = { |
| clone: clone |
| }; |
| $animate.enter(clone, $element.parent(), $element); |
| }); |
| } |
| } else { |
| if (previousElements) { |
| previousElements.remove(); |
| previousElements = null; |
| } |
| if (childScope) { |
| childScope.$destroy(); |
| childScope = null; |
| } |
| if (block) { |
| previousElements = getBlockNodes(block.clone); |
| $animate.leave(previousElements).then(function() { |
| previousElements = null; |
| }); |
| block = null; |
| } |
| } |
| }); |
| } |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngInclude |
| * @restrict ECA |
| * |
| * @description |
| * Fetches, compiles and includes an external HTML fragment. |
| * |
| * By default, the template URL is restricted to the same domain and protocol as the |
| * application document. This is done by calling {@link $sce#getTrustedResourceUrl |
| * $sce.getTrustedResourceUrl} on it. To load templates from other domains or protocols |
| * you may either {@link ng.$sceDelegateProvider#resourceUrlWhitelist whitelist them} or |
| * {@link $sce#trustAsResourceUrl wrap them} as trusted values. Refer to Angular's {@link |
| * ng.$sce Strict Contextual Escaping}. |
| * |
| * In addition, the browser's |
| * [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest) |
| * and [Cross-Origin Resource Sharing (CORS)](http://www.w3.org/TR/cors/) |
| * policy may further restrict whether the template is successfully loaded. |
| * For example, `ngInclude` won't work for cross-domain requests on all browsers and for `file://` |
| * access on some browsers. |
| * |
| * @animations |
| * enter - animation is used to bring new content into the browser. |
| * leave - animation is used to animate existing content away. |
| * |
| * The enter and leave animation occur concurrently. |
| * |
| * @scope |
| * @priority 400 |
| * |
| * @param {string} ngInclude|src angular expression evaluating to URL. If the source is a string constant, |
| * make sure you wrap it in **single** quotes, e.g. `src="'myPartialTemplate.html'"`. |
| * @param {string=} onload Expression to evaluate when a new partial is loaded. |
| * |
| * @param {string=} autoscroll Whether `ngInclude` should call {@link ng.$anchorScroll |
| * $anchorScroll} to scroll the viewport after the content is loaded. |
| * |
| * - If the attribute is not set, disable scrolling. |
| * - If the attribute is set without value, enable scrolling. |
| * - Otherwise enable scrolling only if the expression evaluates to truthy value. |
| * |
| * @example |
| <example module="includeExample" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <select ng-model="template" ng-options="t.name for t in templates"> |
| <option value="">(blank)</option> |
| </select> |
| url of the template: <code>{{template.url}}</code> |
| <hr/> |
| <div class="slide-animate-container"> |
| <div class="slide-animate" ng-include="template.url"></div> |
| </div> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('includeExample', ['ngAnimate']) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.templates = |
| [ { name: 'template1.html', url: 'template1.html'}, |
| { name: 'template2.html', url: 'template2.html'} ]; |
| $scope.template = $scope.templates[0]; |
| }]); |
| </file> |
| <file name="template1.html"> |
| Content of template1.html |
| </file> |
| <file name="template2.html"> |
| Content of template2.html |
| </file> |
| <file name="animations.css"> |
| .slide-animate-container { |
| position:relative; |
| background:white; |
| border:1px solid black; |
| height:40px; |
| overflow:hidden; |
| } |
| |
| .slide-animate { |
| padding:10px; |
| } |
| |
| .slide-animate.ng-enter, .slide-animate.ng-leave { |
| transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s; |
| |
| position:absolute; |
| top:0; |
| left:0; |
| right:0; |
| bottom:0; |
| display:block; |
| padding:10px; |
| } |
| |
| .slide-animate.ng-enter { |
| top:-50px; |
| } |
| .slide-animate.ng-enter.ng-enter-active { |
| top:0; |
| } |
| |
| .slide-animate.ng-leave { |
| top:0; |
| } |
| .slide-animate.ng-leave.ng-leave-active { |
| top:50px; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var templateSelect = element(by.model('template')); |
| var includeElem = element(by.css('[ng-include]')); |
| |
| it('should load template1.html', function() { |
| expect(includeElem.getText()).toMatch(/Content of template1.html/); |
| }); |
| |
| it('should load template2.html', function() { |
| if (browser.params.browser == 'firefox') { |
| // Firefox can't handle using selects |
| // See https://github.com/angular/protractor/issues/480 |
| return; |
| } |
| templateSelect.click(); |
| templateSelect.all(by.css('option')).get(2).click(); |
| expect(includeElem.getText()).toMatch(/Content of template2.html/); |
| }); |
| |
| it('should change to blank', function() { |
| if (browser.params.browser == 'firefox') { |
| // Firefox can't handle using selects |
| return; |
| } |
| templateSelect.click(); |
| templateSelect.all(by.css('option')).get(0).click(); |
| expect(includeElem.isPresent()).toBe(false); |
| }); |
| </file> |
| </example> |
| */ |
| |
| |
| /** |
| * @ngdoc event |
| * @name ngInclude#$includeContentRequested |
| * @eventType emit on the scope ngInclude was declared in |
| * @description |
| * Emitted every time the ngInclude content is requested. |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {String} src URL of content to load. |
| */ |
| |
| |
| /** |
| * @ngdoc event |
| * @name ngInclude#$includeContentLoaded |
| * @eventType emit on the current ngInclude scope |
| * @description |
| * Emitted every time the ngInclude content is reloaded. |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {String} src URL of content to load. |
| */ |
| |
| |
| /** |
| * @ngdoc event |
| * @name ngInclude#$includeContentError |
| * @eventType emit on the scope ngInclude was declared in |
| * @description |
| * Emitted when a template HTTP request yields an erroneous response (status < 200 || status > 299) |
| * |
| * @param {Object} angularEvent Synthetic event object. |
| * @param {String} src URL of content to load. |
| */ |
| var ngIncludeDirective = ['$templateRequest', '$anchorScroll', '$animate', |
| function($templateRequest, $anchorScroll, $animate) { |
| return { |
| restrict: 'ECA', |
| priority: 400, |
| terminal: true, |
| transclude: 'element', |
| controller: angular.noop, |
| compile: function(element, attr) { |
| var srcExp = attr.ngInclude || attr.src, |
| onloadExp = attr.onload || '', |
| autoScrollExp = attr.autoscroll; |
| |
| return function(scope, $element, $attr, ctrl, $transclude) { |
| var changeCounter = 0, |
| currentScope, |
| previousElement, |
| currentElement; |
| |
| var cleanupLastIncludeContent = function() { |
| if (previousElement) { |
| previousElement.remove(); |
| previousElement = null; |
| } |
| if (currentScope) { |
| currentScope.$destroy(); |
| currentScope = null; |
| } |
| if (currentElement) { |
| $animate.leave(currentElement).then(function() { |
| previousElement = null; |
| }); |
| previousElement = currentElement; |
| currentElement = null; |
| } |
| }; |
| |
| scope.$watch(srcExp, function ngIncludeWatchAction(src) { |
| var afterAnimation = function() { |
| if (isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) { |
| $anchorScroll(); |
| } |
| }; |
| var thisChangeId = ++changeCounter; |
| |
| if (src) { |
| //set the 2nd param to true to ignore the template request error so that the inner |
| //contents and scope can be cleaned up. |
| $templateRequest(src, true).then(function(response) { |
| if (thisChangeId !== changeCounter) return; |
| var newScope = scope.$new(); |
| ctrl.template = response; |
| |
| // Note: This will also link all children of ng-include that were contained in the original |
| // html. If that content contains controllers, ... they could pollute/change the scope. |
| // However, using ng-include on an element with additional content does not make sense... |
| // Note: We can't remove them in the cloneAttchFn of $transclude as that |
| // function is called before linking the content, which would apply child |
| // directives to non existing elements. |
| var clone = $transclude(newScope, function(clone) { |
| cleanupLastIncludeContent(); |
| $animate.enter(clone, null, $element).then(afterAnimation); |
| }); |
| |
| currentScope = newScope; |
| currentElement = clone; |
| |
| currentScope.$emit('$includeContentLoaded', src); |
| scope.$eval(onloadExp); |
| }, function() { |
| if (thisChangeId === changeCounter) { |
| cleanupLastIncludeContent(); |
| scope.$emit('$includeContentError', src); |
| } |
| }); |
| scope.$emit('$includeContentRequested', src); |
| } else { |
| cleanupLastIncludeContent(); |
| ctrl.template = null; |
| } |
| }); |
| }; |
| } |
| }; |
| }]; |
| |
| // This directive is called during the $transclude call of the first `ngInclude` directive. |
| // It will replace and compile the content of the element with the loaded template. |
| // We need this directive so that the element content is already filled when |
| // the link function of another directive on the same element as ngInclude |
| // is called. |
| var ngIncludeFillContentDirective = ['$compile', |
| function($compile) { |
| return { |
| restrict: 'ECA', |
| priority: -400, |
| require: 'ngInclude', |
| link: function(scope, $element, $attr, ctrl) { |
| if (/SVG/.test($element[0].toString())) { |
| // WebKit: https://bugs.webkit.org/show_bug.cgi?id=135698 --- SVG elements do not |
| // support innerHTML, so detect this here and try to generate the contents |
| // specially. |
| $element.empty(); |
| $compile(jqLiteBuildFragment(ctrl.template, document).childNodes)(scope, |
| function namespaceAdaptedClone(clone) { |
| $element.append(clone); |
| }, {futureParentElement: $element}); |
| return; |
| } |
| |
| $element.html(ctrl.template); |
| $compile($element.contents())(scope); |
| } |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngInit |
| * @restrict AC |
| * |
| * @description |
| * The `ngInit` directive allows you to evaluate an expression in the |
| * current scope. |
| * |
| * <div class="alert alert-danger"> |
| * This directive can be abused to add unnecessary amounts of logic into your templates. |
| * There are only a few appropriate uses of `ngInit`, such as for aliasing special properties of |
| * {@link ng.directive:ngRepeat `ngRepeat`}, as seen in the demo below; and for injecting data via |
| * server side scripting. Besides these few cases, you should use {@link guide/controller controllers} |
| * rather than `ngInit` to initialize values on a scope. |
| * </div> |
| * |
| * <div class="alert alert-warning"> |
| * **Note**: If you have assignment in `ngInit` along with a {@link ng.$filter `filter`}, make |
| * sure you have parentheses to ensure correct operator precedence: |
| * <pre class="prettyprint"> |
| * `<div ng-init="test1 = ($index | toString)"></div>` |
| * </pre> |
| * </div> |
| * |
| * @priority 450 |
| * |
| * @element ANY |
| * @param {expression} ngInit {@link guide/expression Expression} to eval. |
| * |
| * @example |
| <example module="initExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('initExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.list = [['a', 'b'], ['c', 'd']]; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <div ng-repeat="innerList in list" ng-init="outerIndex = $index"> |
| <div ng-repeat="value in innerList" ng-init="innerIndex = $index"> |
| <span class="example-init">list[ {{outerIndex}} ][ {{innerIndex}} ] = {{value}};</span> |
| </div> |
| </div> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should alias index positions', function() { |
| var elements = element.all(by.css('.example-init')); |
| expect(elements.get(0).getText()).toBe('list[ 0 ][ 0 ] = a;'); |
| expect(elements.get(1).getText()).toBe('list[ 0 ][ 1 ] = b;'); |
| expect(elements.get(2).getText()).toBe('list[ 1 ][ 0 ] = c;'); |
| expect(elements.get(3).getText()).toBe('list[ 1 ][ 1 ] = d;'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngInitDirective = ngDirective({ |
| priority: 450, |
| compile: function() { |
| return { |
| pre: function(scope, element, attrs) { |
| scope.$eval(attrs.ngInit); |
| } |
| }; |
| } |
| }); |
| |
| /** |
| * @ngdoc directive |
| * @name ngList |
| * |
| * @description |
| * Text input that converts between a delimited string and an array of strings. The default |
| * delimiter is a comma followed by a space - equivalent to `ng-list=", "`. You can specify a custom |
| * delimiter as the value of the `ngList` attribute - for example, `ng-list=" | "`. |
| * |
| * The behaviour of the directive is affected by the use of the `ngTrim` attribute. |
| * * If `ngTrim` is set to `"false"` then whitespace around both the separator and each |
| * list item is respected. This implies that the user of the directive is responsible for |
| * dealing with whitespace but also allows you to use whitespace as a delimiter, such as a |
| * tab or newline character. |
| * * Otherwise whitespace around the delimiter is ignored when splitting (although it is respected |
| * when joining the list items back together) and whitespace around each list item is stripped |
| * before it is added to the model. |
| * |
| * ### Example with Validation |
| * |
| * <example name="ngList-directive" module="listExample"> |
| * <file name="app.js"> |
| * angular.module('listExample', []) |
| * .controller('ExampleController', ['$scope', function($scope) { |
| * $scope.names = ['morpheus', 'neo', 'trinity']; |
| * }]); |
| * </file> |
| * <file name="index.html"> |
| * <form name="myForm" ng-controller="ExampleController"> |
| * <label>List: <input name="namesInput" ng-model="names" ng-list required></label> |
| * <span role="alert"> |
| * <span class="error" ng-show="myForm.namesInput.$error.required"> |
| * Required!</span> |
| * </span> |
| * <br> |
| * <tt>names = {{names}}</tt><br/> |
| * <tt>myForm.namesInput.$valid = {{myForm.namesInput.$valid}}</tt><br/> |
| * <tt>myForm.namesInput.$error = {{myForm.namesInput.$error}}</tt><br/> |
| * <tt>myForm.$valid = {{myForm.$valid}}</tt><br/> |
| * <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/> |
| * </form> |
| * </file> |
| * <file name="protractor.js" type="protractor"> |
| * var listInput = element(by.model('names')); |
| * var names = element(by.exactBinding('names')); |
| * var valid = element(by.binding('myForm.namesInput.$valid')); |
| * var error = element(by.css('span.error')); |
| * |
| * it('should initialize to model', function() { |
| * expect(names.getText()).toContain('["morpheus","neo","trinity"]'); |
| * expect(valid.getText()).toContain('true'); |
| * expect(error.getCssValue('display')).toBe('none'); |
| * }); |
| * |
| * it('should be invalid if empty', function() { |
| * listInput.clear(); |
| * listInput.sendKeys(''); |
| * |
| * expect(names.getText()).toContain(''); |
| * expect(valid.getText()).toContain('false'); |
| * expect(error.getCssValue('display')).not.toBe('none'); |
| * }); |
| * </file> |
| * </example> |
| * |
| * ### Example - splitting on newline |
| * <example name="ngList-directive-newlines"> |
| * <file name="index.html"> |
| * <textarea ng-model="list" ng-list=" " ng-trim="false"></textarea> |
| * <pre>{{ list | json }}</pre> |
| * </file> |
| * <file name="protractor.js" type="protractor"> |
| * it("should split the text by newlines", function() { |
| * var listInput = element(by.model('list')); |
| * var output = element(by.binding('list | json')); |
| * listInput.sendKeys('abc\ndef\nghi'); |
| * expect(output.getText()).toContain('[\n "abc",\n "def",\n "ghi"\n]'); |
| * }); |
| * </file> |
| * </example> |
| * |
| * @element input |
| * @param {string=} ngList optional delimiter that should be used to split the value. |
| */ |
| var ngListDirective = function() { |
| return { |
| restrict: 'A', |
| priority: 100, |
| require: 'ngModel', |
| link: function(scope, element, attr, ctrl) { |
| // We want to control whitespace trimming so we use this convoluted approach |
| // to access the ngList attribute, which doesn't pre-trim the attribute |
| var ngList = element.attr(attr.$attr.ngList) || ', '; |
| var trimValues = attr.ngTrim !== 'false'; |
| var separator = trimValues ? trim(ngList) : ngList; |
| |
| var parse = function(viewValue) { |
| // If the viewValue is invalid (say required but empty) it will be `undefined` |
| if (isUndefined(viewValue)) return; |
| |
| var list = []; |
| |
| if (viewValue) { |
| forEach(viewValue.split(separator), function(value) { |
| if (value) list.push(trimValues ? trim(value) : value); |
| }); |
| } |
| |
| return list; |
| }; |
| |
| ctrl.$parsers.push(parse); |
| ctrl.$formatters.push(function(value) { |
| if (isArray(value)) { |
| return value.join(ngList); |
| } |
| |
| return undefined; |
| }); |
| |
| // Override the standard $isEmpty because an empty array means the input is empty. |
| ctrl.$isEmpty = function(value) { |
| return !value || !value.length; |
| }; |
| } |
| }; |
| }; |
| |
| /* global VALID_CLASS: true, |
| INVALID_CLASS: true, |
| PRISTINE_CLASS: true, |
| DIRTY_CLASS: true, |
| UNTOUCHED_CLASS: true, |
| TOUCHED_CLASS: true, |
| */ |
| |
| var VALID_CLASS = 'ng-valid', |
| INVALID_CLASS = 'ng-invalid', |
| PRISTINE_CLASS = 'ng-pristine', |
| DIRTY_CLASS = 'ng-dirty', |
| UNTOUCHED_CLASS = 'ng-untouched', |
| TOUCHED_CLASS = 'ng-touched', |
| PENDING_CLASS = 'ng-pending'; |
| |
| var ngModelMinErr = minErr('ngModel'); |
| |
| /** |
| * @ngdoc type |
| * @name ngModel.NgModelController |
| * |
| * @property {*} $viewValue The actual value from the control's view. For `input` elements, this is a |
| * String. See {@link ngModel.NgModelController#$setViewValue} for information about when the $viewValue |
| * is set. |
| * @property {*} $modelValue The value in the model that the control is bound to. |
| * @property {Array.<Function>} $parsers Array of functions to execute, as a pipeline, whenever |
| the control reads value from the DOM. The functions are called in array order, each passing |
| its return value through to the next. The last return value is forwarded to the |
| {@link ngModel.NgModelController#$validators `$validators`} collection. |
| |
| Parsers are used to sanitize / convert the {@link ngModel.NgModelController#$viewValue |
| `$viewValue`}. |
| |
| Returning `undefined` from a parser means a parse error occurred. In that case, |
| no {@link ngModel.NgModelController#$validators `$validators`} will run and the `ngModel` |
| will be set to `undefined` unless {@link ngModelOptions `ngModelOptions.allowInvalid`} |
| is set to `true`. The parse error is stored in `ngModel.$error.parse`. |
| |
| * |
| * @property {Array.<Function>} $formatters Array of functions to execute, as a pipeline, whenever |
| the model value changes. The functions are called in reverse array order, each passing the value through to the |
| next. The last return value is used as the actual DOM value. |
| Used to format / convert values for display in the control. |
| * ```js |
| * function formatter(value) { |
| * if (value) { |
| * return value.toUpperCase(); |
| * } |
| * } |
| * ngModel.$formatters.push(formatter); |
| * ``` |
| * |
| * @property {Object.<string, function>} $validators A collection of validators that are applied |
| * whenever the model value changes. The key value within the object refers to the name of the |
| * validator while the function refers to the validation operation. The validation operation is |
| * provided with the model value as an argument and must return a true or false value depending |
| * on the response of that validation. |
| * |
| * ```js |
| * ngModel.$validators.validCharacters = function(modelValue, viewValue) { |
| * var value = modelValue || viewValue; |
| * return /[0-9]+/.test(value) && |
| * /[a-z]+/.test(value) && |
| * /[A-Z]+/.test(value) && |
| * /\W+/.test(value); |
| * }; |
| * ``` |
| * |
| * @property {Object.<string, function>} $asyncValidators A collection of validations that are expected to |
| * perform an asynchronous validation (e.g. a HTTP request). The validation function that is provided |
| * is expected to return a promise when it is run during the model validation process. Once the promise |
| * is delivered then the validation status will be set to true when fulfilled and false when rejected. |
| * When the asynchronous validators are triggered, each of the validators will run in parallel and the model |
| * value will only be updated once all validators have been fulfilled. As long as an asynchronous validator |
| * is unfulfilled, its key will be added to the controllers `$pending` property. Also, all asynchronous validators |
| * will only run once all synchronous validators have passed. |
| * |
| * Please note that if $http is used then it is important that the server returns a success HTTP response code |
| * in order to fulfill the validation and a status level of `4xx` in order to reject the validation. |
| * |
| * ```js |
| * ngModel.$asyncValidators.uniqueUsername = function(modelValue, viewValue) { |
| * var value = modelValue || viewValue; |
| * |
| * // Lookup user by username |
| * return $http.get('/api/users/' + value). |
| * then(function resolved() { |
| * //username exists, this means validation fails |
| * return $q.reject('exists'); |
| * }, function rejected() { |
| * //username does not exist, therefore this validation passes |
| * return true; |
| * }); |
| * }; |
| * ``` |
| * |
| * @property {Array.<Function>} $viewChangeListeners Array of functions to execute whenever the |
| * view value has changed. It is called with no arguments, and its return value is ignored. |
| * This can be used in place of additional $watches against the model value. |
| * |
| * @property {Object} $error An object hash with all failing validator ids as keys. |
| * @property {Object} $pending An object hash with all pending validator ids as keys. |
| * |
| * @property {boolean} $untouched True if control has not lost focus yet. |
| * @property {boolean} $touched True if control has lost focus. |
| * @property {boolean} $pristine True if user has not interacted with the control yet. |
| * @property {boolean} $dirty True if user has already interacted with the control. |
| * @property {boolean} $valid True if there is no error. |
| * @property {boolean} $invalid True if at least one error on the control. |
| * @property {string} $name The name attribute of the control. |
| * |
| * @description |
| * |
| * `NgModelController` provides API for the {@link ngModel `ngModel`} directive. |
| * The controller contains services for data-binding, validation, CSS updates, and value formatting |
| * and parsing. It purposefully does not contain any logic which deals with DOM rendering or |
| * listening to DOM events. |
| * Such DOM related logic should be provided by other directives which make use of |
| * `NgModelController` for data-binding to control elements. |
| * Angular provides this DOM logic for most {@link input `input`} elements. |
| * At the end of this page you can find a {@link ngModel.NgModelController#custom-control-example |
| * custom control example} that uses `ngModelController` to bind to `contenteditable` elements. |
| * |
| * @example |
| * ### Custom Control Example |
| * This example shows how to use `NgModelController` with a custom control to achieve |
| * data-binding. Notice how different directives (`contenteditable`, `ng-model`, and `required`) |
| * collaborate together to achieve the desired result. |
| * |
| * `contenteditable` is an HTML5 attribute, which tells the browser to let the element |
| * contents be edited in place by the user. |
| * |
| * We are using the {@link ng.service:$sce $sce} service here and include the {@link ngSanitize $sanitize} |
| * module to automatically remove "bad" content like inline event listener (e.g. `<span onclick="...">`). |
| * However, as we are using `$sce` the model can still decide to provide unsafe content if it marks |
| * that content using the `$sce` service. |
| * |
| * <example name="NgModelController" module="customControl" deps="angular-sanitize.js"> |
| <file name="style.css"> |
| [contenteditable] { |
| border: 1px solid black; |
| background-color: white; |
| min-height: 20px; |
| } |
| |
| .ng-invalid { |
| border: 1px solid red; |
| } |
| |
| </file> |
| <file name="script.js"> |
| angular.module('customControl', ['ngSanitize']). |
| directive('contenteditable', ['$sce', function($sce) { |
| return { |
| restrict: 'A', // only activate on element attribute |
| require: '?ngModel', // get a hold of NgModelController |
| link: function(scope, element, attrs, ngModel) { |
| if (!ngModel) return; // do nothing if no ng-model |
| |
| // Specify how UI should be updated |
| ngModel.$render = function() { |
| element.html($sce.getTrustedHtml(ngModel.$viewValue || '')); |
| }; |
| |
| // Listen for change events to enable binding |
| element.on('blur keyup change', function() { |
| scope.$evalAsync(read); |
| }); |
| read(); // initialize |
| |
| // Write data to the model |
| function read() { |
| var html = element.html(); |
| // When we clear the content editable the browser leaves a <br> behind |
| // If strip-br attribute is provided then we strip this out |
| if ( attrs.stripBr && html == '<br>' ) { |
| html = ''; |
| } |
| ngModel.$setViewValue(html); |
| } |
| } |
| }; |
| }]); |
| </file> |
| <file name="index.html"> |
| <form name="myForm"> |
| <div contenteditable |
| name="myWidget" ng-model="userContent" |
| strip-br="true" |
| required>Change me!</div> |
| <span ng-show="myForm.myWidget.$error.required">Required!</span> |
| <hr> |
| <textarea ng-model="userContent" aria-label="Dynamic textarea"></textarea> |
| </form> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should data-bind and become invalid', function() { |
| if (browser.params.browser == 'safari' || browser.params.browser == 'firefox') { |
| // SafariDriver can't handle contenteditable |
| // and Firefox driver can't clear contenteditables very well |
| return; |
| } |
| var contentEditable = element(by.css('[contenteditable]')); |
| var content = 'Change me!'; |
| |
| expect(contentEditable.getText()).toEqual(content); |
| |
| contentEditable.clear(); |
| contentEditable.sendKeys(protractor.Key.BACK_SPACE); |
| expect(contentEditable.getText()).toEqual(''); |
| expect(contentEditable.getAttribute('class')).toMatch(/ng-invalid-required/); |
| }); |
| </file> |
| * </example> |
| * |
| * |
| */ |
| var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$parse', '$animate', '$timeout', '$rootScope', '$q', '$interpolate', |
| function($scope, $exceptionHandler, $attr, $element, $parse, $animate, $timeout, $rootScope, $q, $interpolate) { |
| this.$viewValue = Number.NaN; |
| this.$modelValue = Number.NaN; |
| this.$$rawModelValue = undefined; // stores the parsed modelValue / model set from scope regardless of validity. |
| this.$validators = {}; |
| this.$asyncValidators = {}; |
| this.$parsers = []; |
| this.$formatters = []; |
| this.$viewChangeListeners = []; |
| this.$untouched = true; |
| this.$touched = false; |
| this.$pristine = true; |
| this.$dirty = false; |
| this.$valid = true; |
| this.$invalid = false; |
| this.$error = {}; // keep invalid keys here |
| this.$$success = {}; // keep valid keys here |
| this.$pending = undefined; // keep pending keys here |
| this.$name = $interpolate($attr.name || '', false)($scope); |
| this.$$parentForm = nullFormCtrl; |
| |
| var parsedNgModel = $parse($attr.ngModel), |
| parsedNgModelAssign = parsedNgModel.assign, |
| ngModelGet = parsedNgModel, |
| ngModelSet = parsedNgModelAssign, |
| pendingDebounce = null, |
| parserValid, |
| ctrl = this; |
| |
| this.$$setOptions = function(options) { |
| ctrl.$options = options; |
| if (options && options.getterSetter) { |
| var invokeModelGetter = $parse($attr.ngModel + '()'), |
| invokeModelSetter = $parse($attr.ngModel + '($$$p)'); |
| |
| ngModelGet = function($scope) { |
| var modelValue = parsedNgModel($scope); |
| if (isFunction(modelValue)) { |
| modelValue = invokeModelGetter($scope); |
| } |
| return modelValue; |
| }; |
| ngModelSet = function($scope, newValue) { |
| if (isFunction(parsedNgModel($scope))) { |
| invokeModelSetter($scope, {$$$p: ctrl.$modelValue}); |
| } else { |
| parsedNgModelAssign($scope, ctrl.$modelValue); |
| } |
| }; |
| } else if (!parsedNgModel.assign) { |
| throw ngModelMinErr('nonassign', "Expression '{0}' is non-assignable. Element: {1}", |
| $attr.ngModel, startingTag($element)); |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$render |
| * |
| * @description |
| * Called when the view needs to be updated. It is expected that the user of the ng-model |
| * directive will implement this method. |
| * |
| * The `$render()` method is invoked in the following situations: |
| * |
| * * `$rollbackViewValue()` is called. If we are rolling back the view value to the last |
| * committed value then `$render()` is called to update the input control. |
| * * The value referenced by `ng-model` is changed programmatically and both the `$modelValue` and |
| * the `$viewValue` are different from last time. |
| * |
| * Since `ng-model` does not do a deep watch, `$render()` is only invoked if the values of |
| * `$modelValue` and `$viewValue` are actually different from their previous value. If `$modelValue` |
| * or `$viewValue` are objects (rather than a string or number) then `$render()` will not be |
| * invoked if you only change a property on the objects. |
| */ |
| this.$render = noop; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$isEmpty |
| * |
| * @description |
| * This is called when we need to determine if the value of an input is empty. |
| * |
| * For instance, the required directive does this to work out if the input has data or not. |
| * |
| * The default `$isEmpty` function checks whether the value is `undefined`, `''`, `null` or `NaN`. |
| * |
| * You can override this for input directives whose concept of being empty is different from the |
| * default. The `checkboxInputType` directive does this because in its case a value of `false` |
| * implies empty. |
| * |
| * @param {*} value The value of the input to check for emptiness. |
| * @returns {boolean} True if `value` is "empty". |
| */ |
| this.$isEmpty = function(value) { |
| return isUndefined(value) || value === '' || value === null || value !== value; |
| }; |
| |
| var currentValidationRunId = 0; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$setValidity |
| * |
| * @description |
| * Change the validity state, and notify the form. |
| * |
| * This method can be called within $parsers/$formatters or a custom validation implementation. |
| * However, in most cases it should be sufficient to use the `ngModel.$validators` and |
| * `ngModel.$asyncValidators` collections which will call `$setValidity` automatically. |
| * |
| * @param {string} validationErrorKey Name of the validator. The `validationErrorKey` will be assigned |
| * to either `$error[validationErrorKey]` or `$pending[validationErrorKey]` |
| * (for unfulfilled `$asyncValidators`), so that it is available for data-binding. |
| * The `validationErrorKey` should be in camelCase and will get converted into dash-case |
| * for class name. Example: `myError` will result in `ng-valid-my-error` and `ng-invalid-my-error` |
| * class and can be bound to as `{{someForm.someControl.$error.myError}}` . |
| * @param {boolean} isValid Whether the current state is valid (true), invalid (false), pending (undefined), |
| * or skipped (null). Pending is used for unfulfilled `$asyncValidators`. |
| * Skipped is used by Angular when validators do not run because of parse errors and |
| * when `$asyncValidators` do not run because any of the `$validators` failed. |
| */ |
| addSetValidityMethod({ |
| ctrl: this, |
| $element: $element, |
| set: function(object, property) { |
| object[property] = true; |
| }, |
| unset: function(object, property) { |
| delete object[property]; |
| }, |
| $animate: $animate |
| }); |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$setPristine |
| * |
| * @description |
| * Sets the control to its pristine state. |
| * |
| * This method can be called to remove the `ng-dirty` class and set the control to its pristine |
| * state (`ng-pristine` class). A model is considered to be pristine when the control |
| * has not been changed from when first compiled. |
| */ |
| this.$setPristine = function() { |
| ctrl.$dirty = false; |
| ctrl.$pristine = true; |
| $animate.removeClass($element, DIRTY_CLASS); |
| $animate.addClass($element, PRISTINE_CLASS); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$setDirty |
| * |
| * @description |
| * Sets the control to its dirty state. |
| * |
| * This method can be called to remove the `ng-pristine` class and set the control to its dirty |
| * state (`ng-dirty` class). A model is considered to be dirty when the control has been changed |
| * from when first compiled. |
| */ |
| this.$setDirty = function() { |
| ctrl.$dirty = true; |
| ctrl.$pristine = false; |
| $animate.removeClass($element, PRISTINE_CLASS); |
| $animate.addClass($element, DIRTY_CLASS); |
| ctrl.$$parentForm.$setDirty(); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$setUntouched |
| * |
| * @description |
| * Sets the control to its untouched state. |
| * |
| * This method can be called to remove the `ng-touched` class and set the control to its |
| * untouched state (`ng-untouched` class). Upon compilation, a model is set as untouched |
| * by default, however this function can be used to restore that state if the model has |
| * already been touched by the user. |
| */ |
| this.$setUntouched = function() { |
| ctrl.$touched = false; |
| ctrl.$untouched = true; |
| $animate.setClass($element, UNTOUCHED_CLASS, TOUCHED_CLASS); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$setTouched |
| * |
| * @description |
| * Sets the control to its touched state. |
| * |
| * This method can be called to remove the `ng-untouched` class and set the control to its |
| * touched state (`ng-touched` class). A model is considered to be touched when the user has |
| * first focused the control element and then shifted focus away from the control (blur event). |
| */ |
| this.$setTouched = function() { |
| ctrl.$touched = true; |
| ctrl.$untouched = false; |
| $animate.setClass($element, TOUCHED_CLASS, UNTOUCHED_CLASS); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$rollbackViewValue |
| * |
| * @description |
| * Cancel an update and reset the input element's value to prevent an update to the `$modelValue`, |
| * which may be caused by a pending debounced event or because the input is waiting for a some |
| * future event. |
| * |
| * If you have an input that uses `ng-model-options` to set up debounced events or events such |
| * as blur you can have a situation where there is a period when the `$viewValue` |
| * is out of synch with the ngModel's `$modelValue`. |
| * |
| * In this case, you can run into difficulties if you try to update the ngModel's `$modelValue` |
| * programmatically before these debounced/future events have resolved/occurred, because Angular's |
| * dirty checking mechanism is not able to tell whether the model has actually changed or not. |
| * |
| * The `$rollbackViewValue()` method should be called before programmatically changing the model of an |
| * input which may have such events pending. This is important in order to make sure that the |
| * input field will be updated with the new model value and any pending operations are cancelled. |
| * |
| * <example name="ng-model-cancel-update" module="cancel-update-example"> |
| * <file name="app.js"> |
| * angular.module('cancel-update-example', []) |
| * |
| * .controller('CancelUpdateController', ['$scope', function($scope) { |
| * $scope.resetWithCancel = function(e) { |
| * if (e.keyCode == 27) { |
| * $scope.myForm.myInput1.$rollbackViewValue(); |
| * $scope.myValue = ''; |
| * } |
| * }; |
| * $scope.resetWithoutCancel = function(e) { |
| * if (e.keyCode == 27) { |
| * $scope.myValue = ''; |
| * } |
| * }; |
| * }]); |
| * </file> |
| * <file name="index.html"> |
| * <div ng-controller="CancelUpdateController"> |
| * <p>Try typing something in each input. See that the model only updates when you |
| * blur off the input. |
| * </p> |
| * <p>Now see what happens if you start typing then press the Escape key</p> |
| * |
| * <form name="myForm" ng-model-options="{ updateOn: 'blur' }"> |
| * <p id="inputDescription1">With $rollbackViewValue()</p> |
| * <input name="myInput1" aria-describedby="inputDescription1" ng-model="myValue" |
| * ng-keydown="resetWithCancel($event)"><br/> |
| * myValue: "{{ myValue }}" |
| * |
| * <p id="inputDescription2">Without $rollbackViewValue()</p> |
| * <input name="myInput2" aria-describedby="inputDescription2" ng-model="myValue" |
| * ng-keydown="resetWithoutCancel($event)"><br/> |
| * myValue: "{{ myValue }}" |
| * </form> |
| * </div> |
| * </file> |
| * </example> |
| */ |
| this.$rollbackViewValue = function() { |
| $timeout.cancel(pendingDebounce); |
| ctrl.$viewValue = ctrl.$$lastCommittedViewValue; |
| ctrl.$render(); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$validate |
| * |
| * @description |
| * Runs each of the registered validators (first synchronous validators and then |
| * asynchronous validators). |
| * If the validity changes to invalid, the model will be set to `undefined`, |
| * unless {@link ngModelOptions `ngModelOptions.allowInvalid`} is `true`. |
| * If the validity changes to valid, it will set the model to the last available valid |
| * `$modelValue`, i.e. either the last parsed value or the last value set from the scope. |
| */ |
| this.$validate = function() { |
| // ignore $validate before model is initialized |
| if (isNumber(ctrl.$modelValue) && isNaN(ctrl.$modelValue)) { |
| return; |
| } |
| |
| var viewValue = ctrl.$$lastCommittedViewValue; |
| // Note: we use the $$rawModelValue as $modelValue might have been |
| // set to undefined during a view -> model update that found validation |
| // errors. We can't parse the view here, since that could change |
| // the model although neither viewValue nor the model on the scope changed |
| var modelValue = ctrl.$$rawModelValue; |
| |
| var prevValid = ctrl.$valid; |
| var prevModelValue = ctrl.$modelValue; |
| |
| var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid; |
| |
| ctrl.$$runValidators(modelValue, viewValue, function(allValid) { |
| // If there was no change in validity, don't update the model |
| // This prevents changing an invalid modelValue to undefined |
| if (!allowInvalid && prevValid !== allValid) { |
| // Note: Don't check ctrl.$valid here, as we could have |
| // external validators (e.g. calculated on the server), |
| // that just call $setValidity and need the model value |
| // to calculate their validity. |
| ctrl.$modelValue = allValid ? modelValue : undefined; |
| |
| if (ctrl.$modelValue !== prevModelValue) { |
| ctrl.$$writeModelToScope(); |
| } |
| } |
| }); |
| |
| }; |
| |
| this.$$runValidators = function(modelValue, viewValue, doneCallback) { |
| currentValidationRunId++; |
| var localValidationRunId = currentValidationRunId; |
| |
| // check parser error |
| if (!processParseErrors()) { |
| validationDone(false); |
| return; |
| } |
| if (!processSyncValidators()) { |
| validationDone(false); |
| return; |
| } |
| processAsyncValidators(); |
| |
| function processParseErrors() { |
| var errorKey = ctrl.$$parserName || 'parse'; |
| if (isUndefined(parserValid)) { |
| setValidity(errorKey, null); |
| } else { |
| if (!parserValid) { |
| forEach(ctrl.$validators, function(v, name) { |
| setValidity(name, null); |
| }); |
| forEach(ctrl.$asyncValidators, function(v, name) { |
| setValidity(name, null); |
| }); |
| } |
| // Set the parse error last, to prevent unsetting it, should a $validators key == parserName |
| setValidity(errorKey, parserValid); |
| return parserValid; |
| } |
| return true; |
| } |
| |
| function processSyncValidators() { |
| var syncValidatorsValid = true; |
| forEach(ctrl.$validators, function(validator, name) { |
| var result = validator(modelValue, viewValue); |
| syncValidatorsValid = syncValidatorsValid && result; |
| setValidity(name, result); |
| }); |
| if (!syncValidatorsValid) { |
| forEach(ctrl.$asyncValidators, function(v, name) { |
| setValidity(name, null); |
| }); |
| return false; |
| } |
| return true; |
| } |
| |
| function processAsyncValidators() { |
| var validatorPromises = []; |
| var allValid = true; |
| forEach(ctrl.$asyncValidators, function(validator, name) { |
| var promise = validator(modelValue, viewValue); |
| if (!isPromiseLike(promise)) { |
| throw ngModelMinErr("$asyncValidators", |
| "Expected asynchronous validator to return a promise but got '{0}' instead.", promise); |
| } |
| setValidity(name, undefined); |
| validatorPromises.push(promise.then(function() { |
| setValidity(name, true); |
| }, function(error) { |
| allValid = false; |
| setValidity(name, false); |
| })); |
| }); |
| if (!validatorPromises.length) { |
| validationDone(true); |
| } else { |
| $q.all(validatorPromises).then(function() { |
| validationDone(allValid); |
| }, noop); |
| } |
| } |
| |
| function setValidity(name, isValid) { |
| if (localValidationRunId === currentValidationRunId) { |
| ctrl.$setValidity(name, isValid); |
| } |
| } |
| |
| function validationDone(allValid) { |
| if (localValidationRunId === currentValidationRunId) { |
| |
| doneCallback(allValid); |
| } |
| } |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$commitViewValue |
| * |
| * @description |
| * Commit a pending update to the `$modelValue`. |
| * |
| * Updates may be pending by a debounced event or because the input is waiting for a some future |
| * event defined in `ng-model-options`. this method is rarely needed as `NgModelController` |
| * usually handles calling this in response to input events. |
| */ |
| this.$commitViewValue = function() { |
| var viewValue = ctrl.$viewValue; |
| |
| $timeout.cancel(pendingDebounce); |
| |
| // If the view value has not changed then we should just exit, except in the case where there is |
| // a native validator on the element. In this case the validation state may have changed even though |
| // the viewValue has stayed empty. |
| if (ctrl.$$lastCommittedViewValue === viewValue && (viewValue !== '' || !ctrl.$$hasNativeValidators)) { |
| return; |
| } |
| ctrl.$$lastCommittedViewValue = viewValue; |
| |
| // change to dirty |
| if (ctrl.$pristine) { |
| this.$setDirty(); |
| } |
| this.$$parseAndValidate(); |
| }; |
| |
| this.$$parseAndValidate = function() { |
| var viewValue = ctrl.$$lastCommittedViewValue; |
| var modelValue = viewValue; |
| parserValid = isUndefined(modelValue) ? undefined : true; |
| |
| if (parserValid) { |
| for (var i = 0; i < ctrl.$parsers.length; i++) { |
| modelValue = ctrl.$parsers[i](modelValue); |
| if (isUndefined(modelValue)) { |
| parserValid = false; |
| break; |
| } |
| } |
| } |
| if (isNumber(ctrl.$modelValue) && isNaN(ctrl.$modelValue)) { |
| // ctrl.$modelValue has not been touched yet... |
| ctrl.$modelValue = ngModelGet($scope); |
| } |
| var prevModelValue = ctrl.$modelValue; |
| var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid; |
| ctrl.$$rawModelValue = modelValue; |
| |
| if (allowInvalid) { |
| ctrl.$modelValue = modelValue; |
| writeToModelIfNeeded(); |
| } |
| |
| // Pass the $$lastCommittedViewValue here, because the cached viewValue might be out of date. |
| // This can happen if e.g. $setViewValue is called from inside a parser |
| ctrl.$$runValidators(modelValue, ctrl.$$lastCommittedViewValue, function(allValid) { |
| if (!allowInvalid) { |
| // Note: Don't check ctrl.$valid here, as we could have |
| // external validators (e.g. calculated on the server), |
| // that just call $setValidity and need the model value |
| // to calculate their validity. |
| ctrl.$modelValue = allValid ? modelValue : undefined; |
| writeToModelIfNeeded(); |
| } |
| }); |
| |
| function writeToModelIfNeeded() { |
| if (ctrl.$modelValue !== prevModelValue) { |
| ctrl.$$writeModelToScope(); |
| } |
| } |
| }; |
| |
| this.$$writeModelToScope = function() { |
| ngModelSet($scope, ctrl.$modelValue); |
| forEach(ctrl.$viewChangeListeners, function(listener) { |
| try { |
| listener(); |
| } catch (e) { |
| $exceptionHandler(e); |
| } |
| }); |
| }; |
| |
| /** |
| * @ngdoc method |
| * @name ngModel.NgModelController#$setViewValue |
| * |
| * @description |
| * Update the view value. |
| * |
| * This method should be called when a control wants to change the view value; typically, |
| * this is done from within a DOM event handler. For example, the {@link ng.directive:input input} |
| * directive calls it when the value of the input changes and {@link ng.directive:select select} |
| * calls it when an option is selected. |
| * |
| * When `$setViewValue` is called, the new `value` will be staged for committing through the `$parsers` |
| * and `$validators` pipelines. If there are no special {@link ngModelOptions} specified then the staged |
| * value sent directly for processing, finally to be applied to `$modelValue` and then the |
| * **expression** specified in the `ng-model` attribute. Lastly, all the registered change listeners, |
| * in the `$viewChangeListeners` list, are called. |
| * |
| * In case the {@link ng.directive:ngModelOptions ngModelOptions} directive is used with `updateOn` |
| * and the `default` trigger is not listed, all those actions will remain pending until one of the |
| * `updateOn` events is triggered on the DOM element. |
| * All these actions will be debounced if the {@link ng.directive:ngModelOptions ngModelOptions} |
| * directive is used with a custom debounce for this particular event. |
| * Note that a `$digest` is only triggered once the `updateOn` events are fired, or if `debounce` |
| * is specified, once the timer runs out. |
| * |
| * When used with standard inputs, the view value will always be a string (which is in some cases |
| * parsed into another type, such as a `Date` object for `input[date]`.) |
| * However, custom controls might also pass objects to this method. In this case, we should make |
| * a copy of the object before passing it to `$setViewValue`. This is because `ngModel` does not |
| * perform a deep watch of objects, it only looks for a change of identity. If you only change |
| * the property of the object then ngModel will not realise that the object has changed and |
| * will not invoke the `$parsers` and `$validators` pipelines. For this reason, you should |
| * not change properties of the copy once it has been passed to `$setViewValue`. |
| * Otherwise you may cause the model value on the scope to change incorrectly. |
| * |
| * <div class="alert alert-info"> |
| * In any case, the value passed to the method should always reflect the current value |
| * of the control. For example, if you are calling `$setViewValue` for an input element, |
| * you should pass the input DOM value. Otherwise, the control and the scope model become |
| * out of sync. It's also important to note that `$setViewValue` does not call `$render` or change |
| * the control's DOM value in any way. If we want to change the control's DOM value |
| * programmatically, we should update the `ngModel` scope expression. Its new value will be |
| * picked up by the model controller, which will run it through the `$formatters`, `$render` it |
| * to update the DOM, and finally call `$validate` on it. |
| * </div> |
| * |
| * @param {*} value value from the view. |
| * @param {string} trigger Event that triggered the update. |
| */ |
| this.$setViewValue = function(value, trigger) { |
| ctrl.$viewValue = value; |
| if (!ctrl.$options || ctrl.$options.updateOnDefault) { |
| ctrl.$$debounceViewValueCommit(trigger); |
| } |
| }; |
| |
| this.$$debounceViewValueCommit = function(trigger) { |
| var debounceDelay = 0, |
| options = ctrl.$options, |
| debounce; |
| |
| if (options && isDefined(options.debounce)) { |
| debounce = options.debounce; |
| if (isNumber(debounce)) { |
| debounceDelay = debounce; |
| } else if (isNumber(debounce[trigger])) { |
| debounceDelay = debounce[trigger]; |
| } else if (isNumber(debounce['default'])) { |
| debounceDelay = debounce['default']; |
| } |
| } |
| |
| $timeout.cancel(pendingDebounce); |
| if (debounceDelay) { |
| pendingDebounce = $timeout(function() { |
| ctrl.$commitViewValue(); |
| }, debounceDelay); |
| } else if ($rootScope.$$phase) { |
| ctrl.$commitViewValue(); |
| } else { |
| $scope.$apply(function() { |
| ctrl.$commitViewValue(); |
| }); |
| } |
| }; |
| |
| // model -> value |
| // Note: we cannot use a normal scope.$watch as we want to detect the following: |
| // 1. scope value is 'a' |
| // 2. user enters 'b' |
| // 3. ng-change kicks in and reverts scope value to 'a' |
| // -> scope value did not change since the last digest as |
| // ng-change executes in apply phase |
| // 4. view should be changed back to 'a' |
| $scope.$watch(function ngModelWatch() { |
| var modelValue = ngModelGet($scope); |
| |
| // if scope model value and ngModel value are out of sync |
| // TODO(perf): why not move this to the action fn? |
| if (modelValue !== ctrl.$modelValue && |
| // checks for NaN is needed to allow setting the model to NaN when there's an asyncValidator |
| (ctrl.$modelValue === ctrl.$modelValue || modelValue === modelValue) |
| ) { |
| ctrl.$modelValue = ctrl.$$rawModelValue = modelValue; |
| parserValid = undefined; |
| |
| var formatters = ctrl.$formatters, |
| idx = formatters.length; |
| |
| var viewValue = modelValue; |
| while (idx--) { |
| viewValue = formatters[idx](viewValue); |
| } |
| if (ctrl.$viewValue !== viewValue) { |
| ctrl.$viewValue = ctrl.$$lastCommittedViewValue = viewValue; |
| ctrl.$render(); |
| |
| ctrl.$$runValidators(modelValue, viewValue, noop); |
| } |
| } |
| |
| return modelValue; |
| }); |
| }]; |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngModel |
| * |
| * @element input |
| * @priority 1 |
| * |
| * @description |
| * The `ngModel` directive binds an `input`,`select`, `textarea` (or custom form control) to a |
| * property on the scope using {@link ngModel.NgModelController NgModelController}, |
| * which is created and exposed by this directive. |
| * |
| * `ngModel` is responsible for: |
| * |
| * - Binding the view into the model, which other directives such as `input`, `textarea` or `select` |
| * require. |
| * - Providing validation behavior (i.e. required, number, email, url). |
| * - Keeping the state of the control (valid/invalid, dirty/pristine, touched/untouched, validation errors). |
| * - Setting related css classes on the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`, `ng-touched`, `ng-untouched`) including animations. |
| * - Registering the control with its parent {@link ng.directive:form form}. |
| * |
| * Note: `ngModel` will try to bind to the property given by evaluating the expression on the |
| * current scope. If the property doesn't already exist on this scope, it will be created |
| * implicitly and added to the scope. |
| * |
| * For best practices on using `ngModel`, see: |
| * |
| * - [Understanding Scopes](https://github.com/angular/angular.js/wiki/Understanding-Scopes) |
| * |
| * For basic examples, how to use `ngModel`, see: |
| * |
| * - {@link ng.directive:input input} |
| * - {@link input[text] text} |
| * - {@link input[checkbox] checkbox} |
| * - {@link input[radio] radio} |
| * - {@link input[number] number} |
| * - {@link input[email] email} |
| * - {@link input[url] url} |
| * - {@link input[date] date} |
| * - {@link input[datetime-local] datetime-local} |
| * - {@link input[time] time} |
| * - {@link input[month] month} |
| * - {@link input[week] week} |
| * - {@link ng.directive:select select} |
| * - {@link ng.directive:textarea textarea} |
| * |
| * # CSS classes |
| * The following CSS classes are added and removed on the associated input/select/textarea element |
| * depending on the validity of the model. |
| * |
| * - `ng-valid`: the model is valid |
| * - `ng-invalid`: the model is invalid |
| * - `ng-valid-[key]`: for each valid key added by `$setValidity` |
| * - `ng-invalid-[key]`: for each invalid key added by `$setValidity` |
| * - `ng-pristine`: the control hasn't been interacted with yet |
| * - `ng-dirty`: the control has been interacted with |
| * - `ng-touched`: the control has been blurred |
| * - `ng-untouched`: the control hasn't been blurred |
| * - `ng-pending`: any `$asyncValidators` are unfulfilled |
| * |
| * Keep in mind that ngAnimate can detect each of these classes when added and removed. |
| * |
| * ## Animation Hooks |
| * |
| * Animations within models are triggered when any of the associated CSS classes are added and removed |
| * on the input element which is attached to the model. These classes are: `.ng-pristine`, `.ng-dirty`, |
| * `.ng-invalid` and `.ng-valid` as well as any other validations that are performed on the model itself. |
| * The animations that are triggered within ngModel are similar to how they work in ngClass and |
| * animations can be hooked into using CSS transitions, keyframes as well as JS animations. |
| * |
| * The following example shows a simple way to utilize CSS transitions to style an input element |
| * that has been rendered as invalid after it has been validated: |
| * |
| * <pre> |
| * //be sure to include ngAnimate as a module to hook into more |
| * //advanced animations |
| * .my-input { |
| * transition:0.5s linear all; |
| * background: white; |
| * } |
| * .my-input.ng-invalid { |
| * background: red; |
| * color:white; |
| * } |
| * </pre> |
| * |
| * @example |
| * <example deps="angular-animate.js" animations="true" fixBase="true" module="inputExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('inputExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.val = '1'; |
| }]); |
| </script> |
| <style> |
| .my-input { |
| transition:all linear 0.5s; |
| background: transparent; |
| } |
| .my-input.ng-invalid { |
| color:white; |
| background: red; |
| } |
| </style> |
| <p id="inputDescription"> |
| Update input to see transitions when valid/invalid. |
| Integer is a valid value. |
| </p> |
| <form name="testForm" ng-controller="ExampleController"> |
| <input ng-model="val" ng-pattern="/^\d+$/" name="anim" class="my-input" |
| aria-describedby="inputDescription" /> |
| </form> |
| </file> |
| * </example> |
| * |
| * ## Binding to a getter/setter |
| * |
| * Sometimes it's helpful to bind `ngModel` to a getter/setter function. A getter/setter is a |
| * function that returns a representation of the model when called with zero arguments, and sets |
| * the internal state of a model when called with an argument. It's sometimes useful to use this |
| * for models that have an internal representation that's different from what the model exposes |
| * to the view. |
| * |
| * <div class="alert alert-success"> |
| * **Best Practice:** It's best to keep getters fast because Angular is likely to call them more |
| * frequently than other parts of your code. |
| * </div> |
| * |
| * You use this behavior by adding `ng-model-options="{ getterSetter: true }"` to an element that |
| * has `ng-model` attached to it. You can also add `ng-model-options="{ getterSetter: true }"` to |
| * a `<form>`, which will enable this behavior for all `<input>`s within it. See |
| * {@link ng.directive:ngModelOptions `ngModelOptions`} for more. |
| * |
| * The following example shows how to use `ngModel` with a getter/setter: |
| * |
| * @example |
| * <example name="ngModel-getter-setter" module="getterSetterExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <form name="userForm"> |
| <label>Name: |
| <input type="text" name="userName" |
| ng-model="user.name" |
| ng-model-options="{ getterSetter: true }" /> |
| </label> |
| </form> |
| <pre>user.name = <span ng-bind="user.name()"></span></pre> |
| </div> |
| </file> |
| <file name="app.js"> |
| angular.module('getterSetterExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| var _name = 'Brian'; |
| $scope.user = { |
| name: function(newName) { |
| // Note that newName can be undefined for two reasons: |
| // 1. Because it is called as a getter and thus called with no arguments |
| // 2. Because the property should actually be set to undefined. This happens e.g. if the |
| // input is invalid |
| return arguments.length ? (_name = newName) : _name; |
| } |
| }; |
| }]); |
| </file> |
| * </example> |
| */ |
| var ngModelDirective = ['$rootScope', function($rootScope) { |
| return { |
| restrict: 'A', |
| require: ['ngModel', '^?form', '^?ngModelOptions'], |
| controller: NgModelController, |
| // Prelink needs to run before any input directive |
| // so that we can set the NgModelOptions in NgModelController |
| // before anyone else uses it. |
| priority: 1, |
| compile: function ngModelCompile(element) { |
| // Setup initial state of the control |
| element.addClass(PRISTINE_CLASS).addClass(UNTOUCHED_CLASS).addClass(VALID_CLASS); |
| |
| return { |
| pre: function ngModelPreLink(scope, element, attr, ctrls) { |
| var modelCtrl = ctrls[0], |
| formCtrl = ctrls[1] || modelCtrl.$$parentForm; |
| |
| modelCtrl.$$setOptions(ctrls[2] && ctrls[2].$options); |
| |
| // notify others, especially parent forms |
| formCtrl.$addControl(modelCtrl); |
| |
| attr.$observe('name', function(newValue) { |
| if (modelCtrl.$name !== newValue) { |
| modelCtrl.$$parentForm.$$renameControl(modelCtrl, newValue); |
| } |
| }); |
| |
| scope.$on('$destroy', function() { |
| modelCtrl.$$parentForm.$removeControl(modelCtrl); |
| }); |
| }, |
| post: function ngModelPostLink(scope, element, attr, ctrls) { |
| var modelCtrl = ctrls[0]; |
| if (modelCtrl.$options && modelCtrl.$options.updateOn) { |
| element.on(modelCtrl.$options.updateOn, function(ev) { |
| modelCtrl.$$debounceViewValueCommit(ev && ev.type); |
| }); |
| } |
| |
| element.on('blur', function(ev) { |
| if (modelCtrl.$touched) return; |
| |
| if ($rootScope.$$phase) { |
| scope.$evalAsync(modelCtrl.$setTouched); |
| } else { |
| scope.$apply(modelCtrl.$setTouched); |
| } |
| }); |
| } |
| }; |
| } |
| }; |
| }]; |
| |
| var DEFAULT_REGEXP = /(\s+|^)default(\s+|$)/; |
| |
| /** |
| * @ngdoc directive |
| * @name ngModelOptions |
| * |
| * @description |
| * Allows tuning how model updates are done. Using `ngModelOptions` you can specify a custom list of |
| * events that will trigger a model update and/or a debouncing delay so that the actual update only |
| * takes place when a timer expires; this timer will be reset after another change takes place. |
| * |
| * Given the nature of `ngModelOptions`, the value displayed inside input fields in the view might |
| * be different from the value in the actual model. This means that if you update the model you |
| * should also invoke {@link ngModel.NgModelController `$rollbackViewValue`} on the relevant input field in |
| * order to make sure it is synchronized with the model and that any debounced action is canceled. |
| * |
| * The easiest way to reference the control's {@link ngModel.NgModelController `$rollbackViewValue`} |
| * method is by making sure the input is placed inside a form that has a `name` attribute. This is |
| * important because `form` controllers are published to the related scope under the name in their |
| * `name` attribute. |
| * |
| * Any pending changes will take place immediately when an enclosing form is submitted via the |
| * `submit` event. Note that `ngClick` events will occur before the model is updated. Use `ngSubmit` |
| * to have access to the updated model. |
| * |
| * `ngModelOptions` has an effect on the element it's declared on and its descendants. |
| * |
| * @param {Object} ngModelOptions options to apply to the current model. Valid keys are: |
| * - `updateOn`: string specifying which event should the input be bound to. You can set several |
| * events using an space delimited list. There is a special event called `default` that |
| * matches the default events belonging of the control. |
| * - `debounce`: integer value which contains the debounce model update value in milliseconds. A |
| * value of 0 triggers an immediate update. If an object is supplied instead, you can specify a |
| * custom value for each event. For example: |
| * `ng-model-options="{ updateOn: 'default blur', debounce: { 'default': 500, 'blur': 0 } }"` |
| * - `allowInvalid`: boolean value which indicates that the model can be set with values that did |
| * not validate correctly instead of the default behavior of setting the model to undefined. |
| * - `getterSetter`: boolean value which determines whether or not to treat functions bound to |
| `ngModel` as getters/setters. |
| * - `timezone`: Defines the timezone to be used to read/write the `Date` instance in the model for |
| * `<input type="date">`, `<input type="time">`, ... . It understands UTC/GMT and the |
| * continental US time zone abbreviations, but for general use, use a time zone offset, for |
| * example, `'+0430'` (4 hours, 30 minutes east of the Greenwich meridian) |
| * If not specified, the timezone of the browser will be used. |
| * |
| * @example |
| |
| The following example shows how to override immediate updates. Changes on the inputs within the |
| form will update the model only when the control loses focus (blur event). If `escape` key is |
| pressed while the input field is focused, the value is reset to the value in the current model. |
| |
| <example name="ngModelOptions-directive-blur" module="optionsExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <form name="userForm"> |
| <label>Name: |
| <input type="text" name="userName" |
| ng-model="user.name" |
| ng-model-options="{ updateOn: 'blur' }" |
| ng-keyup="cancel($event)" /> |
| </label><br /> |
| <label>Other data: |
| <input type="text" ng-model="user.data" /> |
| </label><br /> |
| </form> |
| <pre>user.name = <span ng-bind="user.name"></span></pre> |
| </div> |
| </file> |
| <file name="app.js"> |
| angular.module('optionsExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.user = { name: 'say', data: '' }; |
| |
| $scope.cancel = function(e) { |
| if (e.keyCode == 27) { |
| $scope.userForm.userName.$rollbackViewValue(); |
| } |
| }; |
| }]); |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var model = element(by.binding('user.name')); |
| var input = element(by.model('user.name')); |
| var other = element(by.model('user.data')); |
| |
| it('should allow custom events', function() { |
| input.sendKeys(' hello'); |
| input.click(); |
| expect(model.getText()).toEqual('say'); |
| other.click(); |
| expect(model.getText()).toEqual('say hello'); |
| }); |
| |
| it('should $rollbackViewValue when model changes', function() { |
| input.sendKeys(' hello'); |
| expect(input.getAttribute('value')).toEqual('say hello'); |
| input.sendKeys(protractor.Key.ESCAPE); |
| expect(input.getAttribute('value')).toEqual('say'); |
| other.click(); |
| expect(model.getText()).toEqual('say'); |
| }); |
| </file> |
| </example> |
| |
| This one shows how to debounce model changes. Model will be updated only 1 sec after last change. |
| If the `Clear` button is pressed, any debounced action is canceled and the value becomes empty. |
| |
| <example name="ngModelOptions-directive-debounce" module="optionsExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <form name="userForm"> |
| <label>Name: |
| <input type="text" name="userName" |
| ng-model="user.name" |
| ng-model-options="{ debounce: 1000 }" /> |
| </label> |
| <button ng-click="userForm.userName.$rollbackViewValue(); user.name=''">Clear</button> |
| <br /> |
| </form> |
| <pre>user.name = <span ng-bind="user.name"></span></pre> |
| </div> |
| </file> |
| <file name="app.js"> |
| angular.module('optionsExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.user = { name: 'say' }; |
| }]); |
| </file> |
| </example> |
| |
| This one shows how to bind to getter/setters: |
| |
| <example name="ngModelOptions-directive-getter-setter" module="getterSetterExample"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <form name="userForm"> |
| <label>Name: |
| <input type="text" name="userName" |
| ng-model="user.name" |
| ng-model-options="{ getterSetter: true }" /> |
| </label> |
| </form> |
| <pre>user.name = <span ng-bind="user.name()"></span></pre> |
| </div> |
| </file> |
| <file name="app.js"> |
| angular.module('getterSetterExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| var _name = 'Brian'; |
| $scope.user = { |
| name: function(newName) { |
| // Note that newName can be undefined for two reasons: |
| // 1. Because it is called as a getter and thus called with no arguments |
| // 2. Because the property should actually be set to undefined. This happens e.g. if the |
| // input is invalid |
| return arguments.length ? (_name = newName) : _name; |
| } |
| }; |
| }]); |
| </file> |
| </example> |
| */ |
| var ngModelOptionsDirective = function() { |
| return { |
| restrict: 'A', |
| controller: ['$scope', '$attrs', function($scope, $attrs) { |
| var that = this; |
| this.$options = copy($scope.$eval($attrs.ngModelOptions)); |
| // Allow adding/overriding bound events |
| if (isDefined(this.$options.updateOn)) { |
| this.$options.updateOnDefault = false; |
| // extract "default" pseudo-event from list of events that can trigger a model update |
| this.$options.updateOn = trim(this.$options.updateOn.replace(DEFAULT_REGEXP, function() { |
| that.$options.updateOnDefault = true; |
| return ' '; |
| })); |
| } else { |
| this.$options.updateOnDefault = true; |
| } |
| }] |
| }; |
| }; |
| |
| |
| |
| // helper methods |
| function addSetValidityMethod(context) { |
| var ctrl = context.ctrl, |
| $element = context.$element, |
| classCache = {}, |
| set = context.set, |
| unset = context.unset, |
| $animate = context.$animate; |
| |
| classCache[INVALID_CLASS] = !(classCache[VALID_CLASS] = $element.hasClass(VALID_CLASS)); |
| |
| ctrl.$setValidity = setValidity; |
| |
| function setValidity(validationErrorKey, state, controller) { |
| if (isUndefined(state)) { |
| createAndSet('$pending', validationErrorKey, controller); |
| } else { |
| unsetAndCleanup('$pending', validationErrorKey, controller); |
| } |
| if (!isBoolean(state)) { |
| unset(ctrl.$error, validationErrorKey, controller); |
| unset(ctrl.$$success, validationErrorKey, controller); |
| } else { |
| if (state) { |
| unset(ctrl.$error, validationErrorKey, controller); |
| set(ctrl.$$success, validationErrorKey, controller); |
| } else { |
| set(ctrl.$error, validationErrorKey, controller); |
| unset(ctrl.$$success, validationErrorKey, controller); |
| } |
| } |
| if (ctrl.$pending) { |
| cachedToggleClass(PENDING_CLASS, true); |
| ctrl.$valid = ctrl.$invalid = undefined; |
| toggleValidationCss('', null); |
| } else { |
| cachedToggleClass(PENDING_CLASS, false); |
| ctrl.$valid = isObjectEmpty(ctrl.$error); |
| ctrl.$invalid = !ctrl.$valid; |
| toggleValidationCss('', ctrl.$valid); |
| } |
| |
| // re-read the state as the set/unset methods could have |
| // combined state in ctrl.$error[validationError] (used for forms), |
| // where setting/unsetting only increments/decrements the value, |
| // and does not replace it. |
| var combinedState; |
| if (ctrl.$pending && ctrl.$pending[validationErrorKey]) { |
| combinedState = undefined; |
| } else if (ctrl.$error[validationErrorKey]) { |
| combinedState = false; |
| } else if (ctrl.$$success[validationErrorKey]) { |
| combinedState = true; |
| } else { |
| combinedState = null; |
| } |
| |
| toggleValidationCss(validationErrorKey, combinedState); |
| ctrl.$$parentForm.$setValidity(validationErrorKey, combinedState, ctrl); |
| } |
| |
| function createAndSet(name, value, controller) { |
| if (!ctrl[name]) { |
| ctrl[name] = {}; |
| } |
| set(ctrl[name], value, controller); |
| } |
| |
| function unsetAndCleanup(name, value, controller) { |
| if (ctrl[name]) { |
| unset(ctrl[name], value, controller); |
| } |
| if (isObjectEmpty(ctrl[name])) { |
| ctrl[name] = undefined; |
| } |
| } |
| |
| function cachedToggleClass(className, switchValue) { |
| if (switchValue && !classCache[className]) { |
| $animate.addClass($element, className); |
| classCache[className] = true; |
| } else if (!switchValue && classCache[className]) { |
| $animate.removeClass($element, className); |
| classCache[className] = false; |
| } |
| } |
| |
| function toggleValidationCss(validationErrorKey, isValid) { |
| validationErrorKey = validationErrorKey ? '-' + snake_case(validationErrorKey, '-') : ''; |
| |
| cachedToggleClass(VALID_CLASS + validationErrorKey, isValid === true); |
| cachedToggleClass(INVALID_CLASS + validationErrorKey, isValid === false); |
| } |
| } |
| |
| function isObjectEmpty(obj) { |
| if (obj) { |
| for (var prop in obj) { |
| if (obj.hasOwnProperty(prop)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name ngNonBindable |
| * @restrict AC |
| * @priority 1000 |
| * |
| * @description |
| * The `ngNonBindable` directive tells Angular not to compile or bind the contents of the current |
| * DOM element. This is useful if the element contains what appears to be Angular directives and |
| * bindings but which should be ignored by Angular. This could be the case if you have a site that |
| * displays snippets of code, for instance. |
| * |
| * @element ANY |
| * |
| * @example |
| * In this example there are two locations where a simple interpolation binding (`{{}}`) is present, |
| * but the one wrapped in `ngNonBindable` is left alone. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <div>Normal: {{1 + 2}}</div> |
| <div ng-non-bindable>Ignored: {{1 + 2}}</div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-non-bindable', function() { |
| expect(element(by.binding('1 + 2')).getText()).toContain('3'); |
| expect(element.all(by.css('div')).last().getText()).toMatch(/1 \+ 2/); |
| }); |
| </file> |
| </example> |
| */ |
| var ngNonBindableDirective = ngDirective({ terminal: true, priority: 1000 }); |
| |
| /* global jqLiteRemove */ |
| |
| var ngOptionsMinErr = minErr('ngOptions'); |
| |
| /** |
| * @ngdoc directive |
| * @name ngOptions |
| * @restrict A |
| * |
| * @description |
| * |
| * The `ngOptions` attribute can be used to dynamically generate a list of `<option>` |
| * elements for the `<select>` element using the array or object obtained by evaluating the |
| * `ngOptions` comprehension expression. |
| * |
| * In many cases, `ngRepeat` can be used on `<option>` elements instead of `ngOptions` to achieve a |
| * similar result. However, `ngOptions` provides some benefits such as reducing memory and |
| * increasing speed by not creating a new scope for each repeated instance, as well as providing |
| * more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the |
| * comprehension expression. `ngOptions` should be used when the `<select>` model needs to be bound |
| * to a non-string value. This is because an option element can only be bound to string values at |
| * present. |
| * |
| * When an item in the `<select>` menu is selected, the array element or object property |
| * represented by the selected option will be bound to the model identified by the `ngModel` |
| * directive. |
| * |
| * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can |
| * be nested into the `<select>` element. This element will then represent the `null` or "not selected" |
| * option. See example below for demonstration. |
| * |
| * ## Complex Models (objects or collections) |
| * |
| * **Note:** By default, `ngModel` watches the model by reference, not value. This is important when |
| * binding any input directive to a model that is an object or a collection. |
| * |
| * Since this is a common situation for `ngOptions` the directive additionally watches the model using |
| * `$watchCollection` when the select has the `multiple` attribute or when there is a `track by` clause in |
| * the options expression. This allows ngOptions to trigger a re-rendering of the options even if the actual |
| * object/collection has not changed identity but only a property on the object or an item in the collection |
| * changes. |
| * |
| * Note that `$watchCollection` does a shallow comparison of the properties of the object (or the items in the collection |
| * if the model is an array). This means that changing a property deeper inside the object/collection that the |
| * first level will not trigger a re-rendering. |
| * |
| * |
| * ## `select` **`as`** |
| * |
| * Using `select` **`as`** will bind the result of the `select` expression to the model, but |
| * the value of the `<select>` and `<option>` html elements will be either the index (for array data sources) |
| * or property name (for object data sources) of the value within the collection. If a **`track by`** expression |
| * is used, the result of that expression will be set as the value of the `option` and `select` elements. |
| * |
| * |
| * ### `select` **`as`** and **`track by`** |
| * |
| * <div class="alert alert-warning"> |
| * Do not use `select` **`as`** and **`track by`** in the same expression. They are not designed to work together. |
| * </div> |
| * |
| * Consider the following example: |
| * |
| * ```html |
| * <select ng-options="item.subItem as item.label for item in values track by item.id" ng-model="selected"></select> |
| * ``` |
| * |
| * ```js |
| * $scope.values = [{ |
| * id: 1, |
| * label: 'aLabel', |
| * subItem: { name: 'aSubItem' } |
| * }, { |
| * id: 2, |
| * label: 'bLabel', |
| * subItem: { name: 'bSubItem' } |
| * }]; |
| * |
| * $scope.selected = { name: 'aSubItem' }; |
| * ``` |
| * |
| * With the purpose of preserving the selection, the **`track by`** expression is always applied to the element |
| * of the data source (to `item` in this example). To calculate whether an element is selected, we do the |
| * following: |
| * |
| * 1. Apply **`track by`** to the elements in the array. In the example: `[1, 2]` |
| * 2. Apply **`track by`** to the already selected value in `ngModel`. |
| * In the example: this is not possible as **`track by`** refers to `item.id`, but the selected |
| * value from `ngModel` is `{name: 'aSubItem'}`, so the **`track by`** expression is applied to |
| * a wrong object, the selected element can't be found, `<select>` is always reset to the "not |
| * selected" option. |
| * |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required The control is considered valid only if value is entered. |
| * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of |
| * `required` when you want to data-bind to the `required` attribute. |
| * @param {comprehension_expression=} ngOptions in one of the following forms: |
| * |
| * * for array data sources: |
| * * `label` **`for`** `value` **`in`** `array` |
| * * `select` **`as`** `label` **`for`** `value` **`in`** `array` |
| * * `label` **`group by`** `group` **`for`** `value` **`in`** `array` |
| * * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array` |
| * * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr` |
| * * `label` **`disable when`** `disable` **`for`** `value` **`in`** `array` **`track by`** `trackexpr` |
| * * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr` |
| * (for including a filter with `track by`) |
| * * for object data sources: |
| * * `label` **`for (`**`key` **`,`** `value`**`) in`** `object` |
| * * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object` |
| * * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object` |
| * * `label` **`disable when`** `disable` **`for (`**`key`**`,`** `value`**`) in`** `object` |
| * * `select` **`as`** `label` **`group by`** `group` |
| * **`for` `(`**`key`**`,`** `value`**`) in`** `object` |
| * * `select` **`as`** `label` **`disable when`** `disable` |
| * **`for` `(`**`key`**`,`** `value`**`) in`** `object` |
| * |
| * Where: |
| * |
| * * `array` / `object`: an expression which evaluates to an array / object to iterate over. |
| * * `value`: local variable which will refer to each item in the `array` or each property value |
| * of `object` during iteration. |
| * * `key`: local variable which will refer to a property name in `object` during iteration. |
| * * `label`: The result of this expression will be the label for `<option>` element. The |
| * `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`). |
| * * `select`: The result of this expression will be bound to the model of the parent `<select>` |
| * element. If not specified, `select` expression will default to `value`. |
| * * `group`: The result of this expression will be used to group options using the `<optgroup>` |
| * DOM element. |
| * * `disable`: The result of this expression will be used to disable the rendered `<option>` |
| * element. Return `true` to disable. |
| * * `trackexpr`: Used when working with an array of objects. The result of this expression will be |
| * used to identify the objects in the array. The `trackexpr` will most likely refer to the |
| * `value` variable (e.g. `value.propertyName`). With this the selection is preserved |
| * even when the options are recreated (e.g. reloaded from the server). |
| * |
| * @example |
| <example module="selectExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('selectExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.colors = [ |
| {name:'black', shade:'dark'}, |
| {name:'white', shade:'light', notAnOption: true}, |
| {name:'red', shade:'dark'}, |
| {name:'blue', shade:'dark', notAnOption: true}, |
| {name:'yellow', shade:'light', notAnOption: false} |
| ]; |
| $scope.myColor = $scope.colors[2]; // red |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <ul> |
| <li ng-repeat="color in colors"> |
| <label>Name: <input ng-model="color.name"></label> |
| <label><input type="checkbox" ng-model="color.notAnOption"> Disabled?</label> |
| <button ng-click="colors.splice($index, 1)" aria-label="Remove">X</button> |
| </li> |
| <li> |
| <button ng-click="colors.push({})">add</button> |
| </li> |
| </ul> |
| <hr/> |
| <label>Color (null not allowed): |
| <select ng-model="myColor" ng-options="color.name for color in colors"></select> |
| </label><br/> |
| <label>Color (null allowed): |
| <span class="nullable"> |
| <select ng-model="myColor" ng-options="color.name for color in colors"> |
| <option value="">-- choose color --</option> |
| </select> |
| </span></label><br/> |
| |
| <label>Color grouped by shade: |
| <select ng-model="myColor" ng-options="color.name group by color.shade for color in colors"> |
| </select> |
| </label><br/> |
| |
| <label>Color grouped by shade, with some disabled: |
| <select ng-model="myColor" |
| ng-options="color.name group by color.shade disable when color.notAnOption for color in colors"> |
| </select> |
| </label><br/> |
| |
| |
| |
| Select <button ng-click="myColor = { name:'not in list', shade: 'other' }">bogus</button>. |
| <br/> |
| <hr/> |
| Currently selected: {{ {selected_color:myColor} }} |
| <div style="border:solid 1px black; height:20px" |
| ng-style="{'background-color':myColor.name}"> |
| </div> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should check ng-options', function() { |
| expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('red'); |
| element.all(by.model('myColor')).first().click(); |
| element.all(by.css('select[ng-model="myColor"] option')).first().click(); |
| expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('black'); |
| element(by.css('.nullable select[ng-model="myColor"]')).click(); |
| element.all(by.css('.nullable select[ng-model="myColor"] option')).first().click(); |
| expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('null'); |
| }); |
| </file> |
| </example> |
| */ |
| |
| // jshint maxlen: false |
| // //00001111111111000000000002222222222000000000000000000000333333333300000000000000000000000004444444444400000000000005555555555555550000000006666666666666660000000777777777777777000000000000000888888888800000000000000000009999999999 |
| var NG_OPTIONS_REGEXP = /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?(?:\s+disable\s+when\s+([\s\S]+?))?\s+for\s+(?:([\$\w][\$\w]*)|(?:\(\s*([\$\w][\$\w]*)\s*,\s*([\$\w][\$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/; |
| // 1: value expression (valueFn) |
| // 2: label expression (displayFn) |
| // 3: group by expression (groupByFn) |
| // 4: disable when expression (disableWhenFn) |
| // 5: array item variable name |
| // 6: object item key variable name |
| // 7: object item value variable name |
| // 8: collection expression |
| // 9: track by expression |
| // jshint maxlen: 100 |
| |
| |
| var ngOptionsDirective = ['$compile', '$parse', function($compile, $parse) { |
| |
| function parseOptionsExpression(optionsExp, selectElement, scope) { |
| |
| var match = optionsExp.match(NG_OPTIONS_REGEXP); |
| if (!(match)) { |
| throw ngOptionsMinErr('iexp', |
| "Expected expression in form of " + |
| "'_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" + |
| " but got '{0}'. Element: {1}", |
| optionsExp, startingTag(selectElement)); |
| } |
| |
| // Extract the parts from the ngOptions expression |
| |
| // The variable name for the value of the item in the collection |
| var valueName = match[5] || match[7]; |
| // The variable name for the key of the item in the collection |
| var keyName = match[6]; |
| |
| // An expression that generates the viewValue for an option if there is a label expression |
| var selectAs = / as /.test(match[0]) && match[1]; |
| // An expression that is used to track the id of each object in the options collection |
| var trackBy = match[9]; |
| // An expression that generates the viewValue for an option if there is no label expression |
| var valueFn = $parse(match[2] ? match[1] : valueName); |
| var selectAsFn = selectAs && $parse(selectAs); |
| var viewValueFn = selectAsFn || valueFn; |
| var trackByFn = trackBy && $parse(trackBy); |
| |
| // Get the value by which we are going to track the option |
| // if we have a trackFn then use that (passing scope and locals) |
| // otherwise just hash the given viewValue |
| var getTrackByValueFn = trackBy ? |
| function(value, locals) { return trackByFn(scope, locals); } : |
| function getHashOfValue(value) { return hashKey(value); }; |
| var getTrackByValue = function(value, key) { |
| return getTrackByValueFn(value, getLocals(value, key)); |
| }; |
| |
| var displayFn = $parse(match[2] || match[1]); |
| var groupByFn = $parse(match[3] || ''); |
| var disableWhenFn = $parse(match[4] || ''); |
| var valuesFn = $parse(match[8]); |
| |
| var locals = {}; |
| var getLocals = keyName ? function(value, key) { |
| locals[keyName] = key; |
| locals[valueName] = value; |
| return locals; |
| } : function(value) { |
| locals[valueName] = value; |
| return locals; |
| }; |
| |
| |
| function Option(selectValue, viewValue, label, group, disabled) { |
| this.selectValue = selectValue; |
| this.viewValue = viewValue; |
| this.label = label; |
| this.group = group; |
| this.disabled = disabled; |
| } |
| |
| function getOptionValuesKeys(optionValues) { |
| var optionValuesKeys; |
| |
| if (!keyName && isArrayLike(optionValues)) { |
| optionValuesKeys = optionValues; |
| } else { |
| // if object, extract keys, in enumeration order, unsorted |
| optionValuesKeys = []; |
| for (var itemKey in optionValues) { |
| if (optionValues.hasOwnProperty(itemKey) && itemKey.charAt(0) !== '$') { |
| optionValuesKeys.push(itemKey); |
| } |
| } |
| } |
| return optionValuesKeys; |
| } |
| |
| return { |
| trackBy: trackBy, |
| getTrackByValue: getTrackByValue, |
| getWatchables: $parse(valuesFn, function(optionValues) { |
| // Create a collection of things that we would like to watch (watchedArray) |
| // so that they can all be watched using a single $watchCollection |
| // that only runs the handler once if anything changes |
| var watchedArray = []; |
| optionValues = optionValues || []; |
| |
| var optionValuesKeys = getOptionValuesKeys(optionValues); |
| var optionValuesLength = optionValuesKeys.length; |
| for (var index = 0; index < optionValuesLength; index++) { |
| var key = (optionValues === optionValuesKeys) ? index : optionValuesKeys[index]; |
| var value = optionValues[key]; |
| |
| var locals = getLocals(optionValues[key], key); |
| var selectValue = getTrackByValueFn(optionValues[key], locals); |
| watchedArray.push(selectValue); |
| |
| // Only need to watch the displayFn if there is a specific label expression |
| if (match[2] || match[1]) { |
| var label = displayFn(scope, locals); |
| watchedArray.push(label); |
| } |
| |
| // Only need to watch the disableWhenFn if there is a specific disable expression |
| if (match[4]) { |
| var disableWhen = disableWhenFn(scope, locals); |
| watchedArray.push(disableWhen); |
| } |
| } |
| return watchedArray; |
| }), |
| |
| getOptions: function() { |
| |
| var optionItems = []; |
| var selectValueMap = {}; |
| |
| // The option values were already computed in the `getWatchables` fn, |
| // which must have been called to trigger `getOptions` |
| var optionValues = valuesFn(scope) || []; |
| var optionValuesKeys = getOptionValuesKeys(optionValues); |
| var optionValuesLength = optionValuesKeys.length; |
| |
| for (var index = 0; index < optionValuesLength; index++) { |
| var key = (optionValues === optionValuesKeys) ? index : optionValuesKeys[index]; |
| var value = optionValues[key]; |
| var locals = getLocals(value, key); |
| var viewValue = viewValueFn(scope, locals); |
| var selectValue = getTrackByValueFn(viewValue, locals); |
| var label = displayFn(scope, locals); |
| var group = groupByFn(scope, locals); |
| var disabled = disableWhenFn(scope, locals); |
| var optionItem = new Option(selectValue, viewValue, label, group, disabled); |
| |
| optionItems.push(optionItem); |
| selectValueMap[selectValue] = optionItem; |
| } |
| |
| return { |
| items: optionItems, |
| selectValueMap: selectValueMap, |
| getOptionFromViewValue: function(value) { |
| return selectValueMap[getTrackByValue(value)]; |
| }, |
| getViewValueFromOption: function(option) { |
| // If the viewValue could be an object that may be mutated by the application, |
| // we need to make a copy and not return the reference to the value on the option. |
| return trackBy ? angular.copy(option.viewValue) : option.viewValue; |
| } |
| }; |
| } |
| }; |
| } |
| |
| |
| // we can't just jqLite('<option>') since jqLite is not smart enough |
| // to create it in <select> and IE barfs otherwise. |
| var optionTemplate = document.createElement('option'), |
| optGroupTemplate = document.createElement('optgroup'); |
| |
| return { |
| restrict: 'A', |
| terminal: true, |
| require: ['select', '?ngModel'], |
| link: function(scope, selectElement, attr, ctrls) { |
| |
| // if ngModel is not defined, we don't need to do anything |
| var ngModelCtrl = ctrls[1]; |
| if (!ngModelCtrl) return; |
| |
| var selectCtrl = ctrls[0]; |
| var multiple = attr.multiple; |
| |
| // The emptyOption allows the application developer to provide their own custom "empty" |
| // option when the viewValue does not match any of the option values. |
| var emptyOption; |
| for (var i = 0, children = selectElement.children(), ii = children.length; i < ii; i++) { |
| if (children[i].value === '') { |
| emptyOption = children.eq(i); |
| break; |
| } |
| } |
| |
| var providedEmptyOption = !!emptyOption; |
| |
| var unknownOption = jqLite(optionTemplate.cloneNode(false)); |
| unknownOption.val('?'); |
| |
| var options; |
| var ngOptions = parseOptionsExpression(attr.ngOptions, selectElement, scope); |
| |
| |
| var renderEmptyOption = function() { |
| if (!providedEmptyOption) { |
| selectElement.prepend(emptyOption); |
| } |
| selectElement.val(''); |
| emptyOption.prop('selected', true); // needed for IE |
| emptyOption.attr('selected', true); |
| }; |
| |
| var removeEmptyOption = function() { |
| if (!providedEmptyOption) { |
| emptyOption.remove(); |
| } |
| }; |
| |
| |
| var renderUnknownOption = function() { |
| selectElement.prepend(unknownOption); |
| selectElement.val('?'); |
| unknownOption.prop('selected', true); // needed for IE |
| unknownOption.attr('selected', true); |
| }; |
| |
| var removeUnknownOption = function() { |
| unknownOption.remove(); |
| }; |
| |
| |
| // Update the controller methods for multiple selectable options |
| if (!multiple) { |
| |
| selectCtrl.writeValue = function writeNgOptionsValue(value) { |
| var option = options.getOptionFromViewValue(value); |
| |
| if (option && !option.disabled) { |
| if (selectElement[0].value !== option.selectValue) { |
| removeUnknownOption(); |
| removeEmptyOption(); |
| |
| selectElement[0].value = option.selectValue; |
| option.element.selected = true; |
| option.element.setAttribute('selected', 'selected'); |
| } |
| } else { |
| if (value === null || providedEmptyOption) { |
| removeUnknownOption(); |
| renderEmptyOption(); |
| } else { |
| removeEmptyOption(); |
| renderUnknownOption(); |
| } |
| } |
| }; |
| |
| selectCtrl.readValue = function readNgOptionsValue() { |
| |
| var selectedOption = options.selectValueMap[selectElement.val()]; |
| |
| if (selectedOption && !selectedOption.disabled) { |
| removeEmptyOption(); |
| removeUnknownOption(); |
| return options.getViewValueFromOption(selectedOption); |
| } |
| return null; |
| }; |
| |
| // If we are using `track by` then we must watch the tracked value on the model |
| // since ngModel only watches for object identity change |
| if (ngOptions.trackBy) { |
| scope.$watch( |
| function() { return ngOptions.getTrackByValue(ngModelCtrl.$viewValue); }, |
| function() { ngModelCtrl.$render(); } |
| ); |
| } |
| |
| } else { |
| |
| ngModelCtrl.$isEmpty = function(value) { |
| return !value || value.length === 0; |
| }; |
| |
| |
| selectCtrl.writeValue = function writeNgOptionsMultiple(value) { |
| options.items.forEach(function(option) { |
| option.element.selected = false; |
| }); |
| |
| if (value) { |
| value.forEach(function(item) { |
| var option = options.getOptionFromViewValue(item); |
| if (option && !option.disabled) option.element.selected = true; |
| }); |
| } |
| }; |
| |
| |
| selectCtrl.readValue = function readNgOptionsMultiple() { |
| var selectedValues = selectElement.val() || [], |
| selections = []; |
| |
| forEach(selectedValues, function(value) { |
| var option = options.selectValueMap[value]; |
| if (option && !option.disabled) selections.push(options.getViewValueFromOption(option)); |
| }); |
| |
| return selections; |
| }; |
| |
| // If we are using `track by` then we must watch these tracked values on the model |
| // since ngModel only watches for object identity change |
| if (ngOptions.trackBy) { |
| |
| scope.$watchCollection(function() { |
| if (isArray(ngModelCtrl.$viewValue)) { |
| return ngModelCtrl.$viewValue.map(function(value) { |
| return ngOptions.getTrackByValue(value); |
| }); |
| } |
| }, function() { |
| ngModelCtrl.$render(); |
| }); |
| |
| } |
| } |
| |
| |
| if (providedEmptyOption) { |
| |
| // we need to remove it before calling selectElement.empty() because otherwise IE will |
| // remove the label from the element. wtf? |
| emptyOption.remove(); |
| |
| // compile the element since there might be bindings in it |
| $compile(emptyOption)(scope); |
| |
| // remove the class, which is added automatically because we recompile the element and it |
| // becomes the compilation root |
| emptyOption.removeClass('ng-scope'); |
| } else { |
| emptyOption = jqLite(optionTemplate.cloneNode(false)); |
| } |
| |
| // We need to do this here to ensure that the options object is defined |
| // when we first hit it in writeNgOptionsValue |
| updateOptions(); |
| |
| // We will re-render the option elements if the option values or labels change |
| scope.$watchCollection(ngOptions.getWatchables, updateOptions); |
| |
| // ------------------------------------------------------------------ // |
| |
| |
| function updateOptionElement(option, element) { |
| option.element = element; |
| element.disabled = option.disabled; |
| // NOTE: The label must be set before the value, otherwise IE10/11/EDGE create unresponsive |
| // selects in certain circumstances when multiple selects are next to each other and display |
| // the option list in listbox style, i.e. the select is [multiple], or specifies a [size]. |
| // See https://github.com/angular/angular.js/issues/11314 for more info. |
| // This is unfortunately untestable with unit / e2e tests |
| if (option.label !== element.label) { |
| element.label = option.label; |
| element.textContent = option.label; |
| } |
| if (option.value !== element.value) element.value = option.selectValue; |
| } |
| |
| function addOrReuseElement(parent, current, type, templateElement) { |
| var element; |
| // Check whether we can reuse the next element |
| if (current && lowercase(current.nodeName) === type) { |
| // The next element is the right type so reuse it |
| element = current; |
| } else { |
| // The next element is not the right type so create a new one |
| element = templateElement.cloneNode(false); |
| if (!current) { |
| // There are no more elements so just append it to the select |
| parent.appendChild(element); |
| } else { |
| // The next element is not a group so insert the new one |
| parent.insertBefore(element, current); |
| } |
| } |
| return element; |
| } |
| |
| |
| function removeExcessElements(current) { |
| var next; |
| while (current) { |
| next = current.nextSibling; |
| jqLiteRemove(current); |
| current = next; |
| } |
| } |
| |
| |
| function skipEmptyAndUnknownOptions(current) { |
| var emptyOption_ = emptyOption && emptyOption[0]; |
| var unknownOption_ = unknownOption && unknownOption[0]; |
| |
| if (emptyOption_ || unknownOption_) { |
| while (current && |
| (current === emptyOption_ || |
| current === unknownOption_ || |
| emptyOption_ && emptyOption_.nodeType === NODE_TYPE_COMMENT)) { |
| // Empty options might have directives that transclude |
| // and insert comments (e.g. ngIf) |
| current = current.nextSibling; |
| } |
| } |
| return current; |
| } |
| |
| |
| function updateOptions() { |
| |
| var previousValue = options && selectCtrl.readValue(); |
| |
| options = ngOptions.getOptions(); |
| |
| var groupMap = {}; |
| var currentElement = selectElement[0].firstChild; |
| |
| // Ensure that the empty option is always there if it was explicitly provided |
| if (providedEmptyOption) { |
| selectElement.prepend(emptyOption); |
| } |
| |
| currentElement = skipEmptyAndUnknownOptions(currentElement); |
| |
| options.items.forEach(function updateOption(option) { |
| var group; |
| var groupElement; |
| var optionElement; |
| |
| if (option.group) { |
| |
| // This option is to live in a group |
| // See if we have already created this group |
| group = groupMap[option.group]; |
| |
| if (!group) { |
| |
| // We have not already created this group |
| groupElement = addOrReuseElement(selectElement[0], |
| currentElement, |
| 'optgroup', |
| optGroupTemplate); |
| // Move to the next element |
| currentElement = groupElement.nextSibling; |
| |
| // Update the label on the group element |
| groupElement.label = option.group; |
| |
| // Store it for use later |
| group = groupMap[option.group] = { |
| groupElement: groupElement, |
| currentOptionElement: groupElement.firstChild |
| }; |
| |
| } |
| |
| // So now we have a group for this option we add the option to the group |
| optionElement = addOrReuseElement(group.groupElement, |
| group.currentOptionElement, |
| 'option', |
| optionTemplate); |
| updateOptionElement(option, optionElement); |
| // Move to the next element |
| group.currentOptionElement = optionElement.nextSibling; |
| |
| } else { |
| |
| // This option is not in a group |
| optionElement = addOrReuseElement(selectElement[0], |
| currentElement, |
| 'option', |
| optionTemplate); |
| updateOptionElement(option, optionElement); |
| // Move to the next element |
| currentElement = optionElement.nextSibling; |
| } |
| }); |
| |
| |
| // Now remove all excess options and group |
| Object.keys(groupMap).forEach(function(key) { |
| removeExcessElements(groupMap[key].currentOptionElement); |
| }); |
| removeExcessElements(currentElement); |
| |
| ngModelCtrl.$render(); |
| |
| // Check to see if the value has changed due to the update to the options |
| if (!ngModelCtrl.$isEmpty(previousValue)) { |
| var nextValue = selectCtrl.readValue(); |
| if (ngOptions.trackBy ? !equals(previousValue, nextValue) : previousValue !== nextValue) { |
| ngModelCtrl.$setViewValue(nextValue); |
| ngModelCtrl.$render(); |
| } |
| } |
| |
| } |
| |
| } |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngPluralize |
| * @restrict EA |
| * |
| * @description |
| * `ngPluralize` is a directive that displays messages according to en-US localization rules. |
| * These rules are bundled with angular.js, but can be overridden |
| * (see {@link guide/i18n Angular i18n} dev guide). You configure ngPluralize directive |
| * by specifying the mappings between |
| * [plural categories](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html) |
| * and the strings to be displayed. |
| * |
| * # Plural categories and explicit number rules |
| * There are two |
| * [plural categories](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html) |
| * in Angular's default en-US locale: "one" and "other". |
| * |
| * While a plural category may match many numbers (for example, in en-US locale, "other" can match |
| * any number that is not 1), an explicit number rule can only match one number. For example, the |
| * explicit number rule for "3" matches the number 3. There are examples of plural categories |
| * and explicit number rules throughout the rest of this documentation. |
| * |
| * # Configuring ngPluralize |
| * You configure ngPluralize by providing 2 attributes: `count` and `when`. |
| * You can also provide an optional attribute, `offset`. |
| * |
| * The value of the `count` attribute can be either a string or an {@link guide/expression |
| * Angular expression}; these are evaluated on the current scope for its bound value. |
| * |
| * The `when` attribute specifies the mappings between plural categories and the actual |
| * string to be displayed. The value of the attribute should be a JSON object. |
| * |
| * The following example shows how to configure ngPluralize: |
| * |
| * ```html |
| * <ng-pluralize count="personCount" |
| when="{'0': 'Nobody is viewing.', |
| * 'one': '1 person is viewing.', |
| * 'other': '{} people are viewing.'}"> |
| * </ng-pluralize> |
| *``` |
| * |
| * In the example, `"0: Nobody is viewing."` is an explicit number rule. If you did not |
| * specify this rule, 0 would be matched to the "other" category and "0 people are viewing" |
| * would be shown instead of "Nobody is viewing". You can specify an explicit number rule for |
| * other numbers, for example 12, so that instead of showing "12 people are viewing", you can |
| * show "a dozen people are viewing". |
| * |
| * You can use a set of closed braces (`{}`) as a placeholder for the number that you want substituted |
| * into pluralized strings. In the previous example, Angular will replace `{}` with |
| * <span ng-non-bindable>`{{personCount}}`</span>. The closed braces `{}` is a placeholder |
| * for <span ng-non-bindable>{{numberExpression}}</span>. |
| * |
| * If no rule is defined for a category, then an empty string is displayed and a warning is generated. |
| * Note that some locales define more categories than `one` and `other`. For example, fr-fr defines `few` and `many`. |
| * |
| * # Configuring ngPluralize with offset |
| * The `offset` attribute allows further customization of pluralized text, which can result in |
| * a better user experience. For example, instead of the message "4 people are viewing this document", |
| * you might display "John, Kate and 2 others are viewing this document". |
| * The offset attribute allows you to offset a number by any desired value. |
| * Let's take a look at an example: |
| * |
| * ```html |
| * <ng-pluralize count="personCount" offset=2 |
| * when="{'0': 'Nobody is viewing.', |
| * '1': '{{person1}} is viewing.', |
| * '2': '{{person1}} and {{person2}} are viewing.', |
| * 'one': '{{person1}}, {{person2}} and one other person are viewing.', |
| * 'other': '{{person1}}, {{person2}} and {} other people are viewing.'}"> |
| * </ng-pluralize> |
| * ``` |
| * |
| * Notice that we are still using two plural categories(one, other), but we added |
| * three explicit number rules 0, 1 and 2. |
| * When one person, perhaps John, views the document, "John is viewing" will be shown. |
| * When three people view the document, no explicit number rule is found, so |
| * an offset of 2 is taken off 3, and Angular uses 1 to decide the plural category. |
| * In this case, plural category 'one' is matched and "John, Mary and one other person are viewing" |
| * is shown. |
| * |
| * Note that when you specify offsets, you must provide explicit number rules for |
| * numbers from 0 up to and including the offset. If you use an offset of 3, for example, |
| * you must provide explicit number rules for 0, 1, 2 and 3. You must also provide plural strings for |
| * plural categories "one" and "other". |
| * |
| * @param {string|expression} count The variable to be bound to. |
| * @param {string} when The mapping between plural category to its corresponding strings. |
| * @param {number=} offset Offset to deduct from the total number. |
| * |
| * @example |
| <example module="pluralizeExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('pluralizeExample', []) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.person1 = 'Igor'; |
| $scope.person2 = 'Misko'; |
| $scope.personCount = 1; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <label>Person 1:<input type="text" ng-model="person1" value="Igor" /></label><br/> |
| <label>Person 2:<input type="text" ng-model="person2" value="Misko" /></label><br/> |
| <label>Number of People:<input type="text" ng-model="personCount" value="1" /></label><br/> |
| |
| <!--- Example with simple pluralization rules for en locale ---> |
| Without Offset: |
| <ng-pluralize count="personCount" |
| when="{'0': 'Nobody is viewing.', |
| 'one': '1 person is viewing.', |
| 'other': '{} people are viewing.'}"> |
| </ng-pluralize><br> |
| |
| <!--- Example with offset ---> |
| With Offset(2): |
| <ng-pluralize count="personCount" offset=2 |
| when="{'0': 'Nobody is viewing.', |
| '1': '{{person1}} is viewing.', |
| '2': '{{person1}} and {{person2}} are viewing.', |
| 'one': '{{person1}}, {{person2}} and one other person are viewing.', |
| 'other': '{{person1}}, {{person2}} and {} other people are viewing.'}"> |
| </ng-pluralize> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should show correct pluralized string', function() { |
| var withoutOffset = element.all(by.css('ng-pluralize')).get(0); |
| var withOffset = element.all(by.css('ng-pluralize')).get(1); |
| var countInput = element(by.model('personCount')); |
| |
| expect(withoutOffset.getText()).toEqual('1 person is viewing.'); |
| expect(withOffset.getText()).toEqual('Igor is viewing.'); |
| |
| countInput.clear(); |
| countInput.sendKeys('0'); |
| |
| expect(withoutOffset.getText()).toEqual('Nobody is viewing.'); |
| expect(withOffset.getText()).toEqual('Nobody is viewing.'); |
| |
| countInput.clear(); |
| countInput.sendKeys('2'); |
| |
| expect(withoutOffset.getText()).toEqual('2 people are viewing.'); |
| expect(withOffset.getText()).toEqual('Igor and Misko are viewing.'); |
| |
| countInput.clear(); |
| countInput.sendKeys('3'); |
| |
| expect(withoutOffset.getText()).toEqual('3 people are viewing.'); |
| expect(withOffset.getText()).toEqual('Igor, Misko and one other person are viewing.'); |
| |
| countInput.clear(); |
| countInput.sendKeys('4'); |
| |
| expect(withoutOffset.getText()).toEqual('4 people are viewing.'); |
| expect(withOffset.getText()).toEqual('Igor, Misko and 2 other people are viewing.'); |
| }); |
| it('should show data-bound names', function() { |
| var withOffset = element.all(by.css('ng-pluralize')).get(1); |
| var personCount = element(by.model('personCount')); |
| var person1 = element(by.model('person1')); |
| var person2 = element(by.model('person2')); |
| personCount.clear(); |
| personCount.sendKeys('4'); |
| person1.clear(); |
| person1.sendKeys('Di'); |
| person2.clear(); |
| person2.sendKeys('Vojta'); |
| expect(withOffset.getText()).toEqual('Di, Vojta and 2 other people are viewing.'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngPluralizeDirective = ['$locale', '$interpolate', '$log', function($locale, $interpolate, $log) { |
| var BRACE = /{}/g, |
| IS_WHEN = /^when(Minus)?(.+)$/; |
| |
| return { |
| link: function(scope, element, attr) { |
| var numberExp = attr.count, |
| whenExp = attr.$attr.when && element.attr(attr.$attr.when), // we have {{}} in attrs |
| offset = attr.offset || 0, |
| whens = scope.$eval(whenExp) || {}, |
| whensExpFns = {}, |
| startSymbol = $interpolate.startSymbol(), |
| endSymbol = $interpolate.endSymbol(), |
| braceReplacement = startSymbol + numberExp + '-' + offset + endSymbol, |
| watchRemover = angular.noop, |
| lastCount; |
| |
| forEach(attr, function(expression, attributeName) { |
| var tmpMatch = IS_WHEN.exec(attributeName); |
| if (tmpMatch) { |
| var whenKey = (tmpMatch[1] ? '-' : '') + lowercase(tmpMatch[2]); |
| whens[whenKey] = element.attr(attr.$attr[attributeName]); |
| } |
| }); |
| forEach(whens, function(expression, key) { |
| whensExpFns[key] = $interpolate(expression.replace(BRACE, braceReplacement)); |
| |
| }); |
| |
| scope.$watch(numberExp, function ngPluralizeWatchAction(newVal) { |
| var count = parseFloat(newVal); |
| var countIsNaN = isNaN(count); |
| |
| if (!countIsNaN && !(count in whens)) { |
| // If an explicit number rule such as 1, 2, 3... is defined, just use it. |
| // Otherwise, check it against pluralization rules in $locale service. |
| count = $locale.pluralCat(count - offset); |
| } |
| |
| // If both `count` and `lastCount` are NaN, we don't need to re-register a watch. |
| // In JS `NaN !== NaN`, so we have to exlicitly check. |
| if ((count !== lastCount) && !(countIsNaN && isNumber(lastCount) && isNaN(lastCount))) { |
| watchRemover(); |
| var whenExpFn = whensExpFns[count]; |
| if (isUndefined(whenExpFn)) { |
| if (newVal != null) { |
| $log.debug("ngPluralize: no rule defined for '" + count + "' in " + whenExp); |
| } |
| watchRemover = noop; |
| updateElementText(); |
| } else { |
| watchRemover = scope.$watch(whenExpFn, updateElementText); |
| } |
| lastCount = count; |
| } |
| }); |
| |
| function updateElementText(newText) { |
| element.text(newText || ''); |
| } |
| } |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngRepeat |
| * @multiElement |
| * |
| * @description |
| * The `ngRepeat` directive instantiates a template once per item from a collection. Each template |
| * instance gets its own scope, where the given loop variable is set to the current collection item, |
| * and `$index` is set to the item index or key. |
| * |
| * Special properties are exposed on the local scope of each template instance, including: |
| * |
| * | Variable | Type | Details | |
| * |-----------|-----------------|-----------------------------------------------------------------------------| |
| * | `$index` | {@type number} | iterator offset of the repeated element (0..length-1) | |
| * | `$first` | {@type boolean} | true if the repeated element is first in the iterator. | |
| * | `$middle` | {@type boolean} | true if the repeated element is between the first and last in the iterator. | |
| * | `$last` | {@type boolean} | true if the repeated element is last in the iterator. | |
| * | `$even` | {@type boolean} | true if the iterator position `$index` is even (otherwise false). | |
| * | `$odd` | {@type boolean} | true if the iterator position `$index` is odd (otherwise false). | |
| * |
| * <div class="alert alert-info"> |
| * Creating aliases for these properties is possible with {@link ng.directive:ngInit `ngInit`}. |
| * This may be useful when, for instance, nesting ngRepeats. |
| * </div> |
| * |
| * |
| * # Iterating over object properties |
| * |
| * It is possible to get `ngRepeat` to iterate over the properties of an object using the following |
| * syntax: |
| * |
| * ```js |
| * <div ng-repeat="(key, value) in myObj"> ... </div> |
| * ``` |
| * |
| * You need to be aware that the JavaScript specification does not define the order of keys |
| * returned for an object. (To mitigate this in Angular 1.3 the `ngRepeat` directive |
| * used to sort the keys alphabetically.) |
| * |
| * Version 1.4 removed the alphabetic sorting. We now rely on the order returned by the browser |
| * when running `for key in myObj`. It seems that browsers generally follow the strategy of providing |
| * keys in the order in which they were defined, although there are exceptions when keys are deleted |
| * and reinstated. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete#Cross-browser_issues |
| * |
| * If this is not desired, the recommended workaround is to convert your object into an array |
| * that is sorted into the order that you prefer before providing it to `ngRepeat`. You could |
| * do this with a filter such as [toArrayFilter](http://ngmodules.org/modules/angular-toArrayFilter) |
| * or implement a `$watch` on the object yourself. |
| * |
| * |
| * # Tracking and Duplicates |
| * |
| * When the contents of the collection change, `ngRepeat` makes the corresponding changes to the DOM: |
| * |
| * * When an item is added, a new instance of the template is added to the DOM. |
| * * When an item is removed, its template instance is removed from the DOM. |
| * * When items are reordered, their respective templates are reordered in the DOM. |
| * |
| * By default, `ngRepeat` does not allow duplicate items in arrays. This is because when |
| * there are duplicates, it is not possible to maintain a one-to-one mapping between collection |
| * items and DOM elements. |
| * |
| * If you do need to repeat duplicate items, you can substitute the default tracking behavior |
| * with your own using the `track by` expression. |
| * |
| * For example, you may track items by the index of each item in the collection, using the |
| * special scope property `$index`: |
| * ```html |
| * <div ng-repeat="n in [42, 42, 43, 43] track by $index"> |
| * {{n}} |
| * </div> |
| * ``` |
| * |
| * You may use arbitrary expressions in `track by`, including references to custom functions |
| * on the scope: |
| * ```html |
| * <div ng-repeat="n in [42, 42, 43, 43] track by myTrackingFunction(n)"> |
| * {{n}} |
| * </div> |
| * ``` |
| * |
| * If you are working with objects that have an identifier property, you can track |
| * by the identifier instead of the whole object. Should you reload your data later, `ngRepeat` |
| * will not have to rebuild the DOM elements for items it has already rendered, even if the |
| * JavaScript objects in the collection have been substituted for new ones: |
| * ```html |
| * <div ng-repeat="model in collection track by model.id"> |
| * {{model.name}} |
| * </div> |
| * ``` |
| * |
| * When no `track by` expression is provided, it is equivalent to tracking by the built-in |
| * `$id` function, which tracks items by their identity: |
| * ```html |
| * <div ng-repeat="obj in collection track by $id(obj)"> |
| * {{obj.prop}} |
| * </div> |
| * ``` |
| * |
| * <div class="alert alert-warning"> |
| * **Note:** `track by` must always be the last expression: |
| * </div> |
| * ``` |
| * <div ng-repeat="model in collection | orderBy: 'id' as filtered_result track by model.id"> |
| * {{model.name}} |
| * </div> |
| * ``` |
| * |
| * # Special repeat start and end points |
| * To repeat a series of elements instead of just one parent element, ngRepeat (as well as other ng directives) supports extending |
| * the range of the repeater by defining explicit start and end points by using **ng-repeat-start** and **ng-repeat-end** respectively. |
| * The **ng-repeat-start** directive works the same as **ng-repeat**, but will repeat all the HTML code (including the tag it's defined on) |
| * up to and including the ending HTML tag where **ng-repeat-end** is placed. |
| * |
| * The example below makes use of this feature: |
| * ```html |
| * <header ng-repeat-start="item in items"> |
| * Header {{ item }} |
| * </header> |
| * <div class="body"> |
| * Body {{ item }} |
| * </div> |
| * <footer ng-repeat-end> |
| * Footer {{ item }} |
| * </footer> |
| * ``` |
| * |
| * And with an input of {@type ['A','B']} for the items variable in the example above, the output will evaluate to: |
| * ```html |
| * <header> |
| * Header A |
| * </header> |
| * <div class="body"> |
| * Body A |
| * </div> |
| * <footer> |
| * Footer A |
| * </footer> |
| * <header> |
| * Header B |
| * </header> |
| * <div class="body"> |
| * Body B |
| * </div> |
| * <footer> |
| * Footer B |
| * </footer> |
| * ``` |
| * |
| * The custom start and end points for ngRepeat also support all other HTML directive syntax flavors provided in AngularJS (such |
| * as **data-ng-repeat-start**, **x-ng-repeat-start** and **ng:repeat-start**). |
| * |
| * @animations |
| * **.enter** - when a new item is added to the list or when an item is revealed after a filter |
| * |
| * **.leave** - when an item is removed from the list or when an item is filtered out |
| * |
| * **.move** - when an adjacent item is filtered out causing a reorder or when the item contents are reordered |
| * |
| * @element ANY |
| * @scope |
| * @priority 1000 |
| * @param {repeat_expression} ngRepeat The expression indicating how to enumerate a collection. These |
| * formats are currently supported: |
| * |
| * * `variable in expression` – where variable is the user defined loop variable and `expression` |
| * is a scope expression giving the collection to enumerate. |
| * |
| * For example: `album in artist.albums`. |
| * |
| * * `(key, value) in expression` – where `key` and `value` can be any user defined identifiers, |
| * and `expression` is the scope expression giving the collection to enumerate. |
| * |
| * For example: `(name, age) in {'adam':10, 'amalie':12}`. |
| * |
| * * `variable in expression track by tracking_expression` – You can also provide an optional tracking expression |
| * which can be used to associate the objects in the collection with the DOM elements. If no tracking expression |
| * is specified, ng-repeat associates elements by identity. It is an error to have |
| * more than one tracking expression value resolve to the same key. (This would mean that two distinct objects are |
| * mapped to the same DOM element, which is not possible.) |
| * |
| * Note that the tracking expression must come last, after any filters, and the alias expression. |
| * |
| * For example: `item in items` is equivalent to `item in items track by $id(item)`. This implies that the DOM elements |
| * will be associated by item identity in the array. |
| * |
| * For example: `item in items track by $id(item)`. A built in `$id()` function can be used to assign a unique |
| * `$$hashKey` property to each item in the array. This property is then used as a key to associated DOM elements |
| * with the corresponding item in the array by identity. Moving the same object in array would move the DOM |
| * element in the same way in the DOM. |
| * |
| * For example: `item in items track by item.id` is a typical pattern when the items come from the database. In this |
| * case the object identity does not matter. Two objects are considered equivalent as long as their `id` |
| * property is same. |
| * |
| * For example: `item in items | filter:searchText track by item.id` is a pattern that might be used to apply a filter |
| * to items in conjunction with a tracking expression. |
| * |
| * * `variable in expression as alias_expression` – You can also provide an optional alias expression which will then store the |
| * intermediate results of the repeater after the filters have been applied. Typically this is used to render a special message |
| * when a filter is active on the repeater, but the filtered result set is empty. |
| * |
| * For example: `item in items | filter:x as results` will store the fragment of the repeated items as `results`, but only after |
| * the items have been processed through the filter. |
| * |
| * Please note that `as [variable name] is not an operator but rather a part of ngRepeat micro-syntax so it can be used only at the end |
| * (and not as operator, inside an expression). |
| * |
| * For example: `item in items | filter : x | orderBy : order | limitTo : limit as results` . |
| * |
| * @example |
| * This example initializes the scope to a list of names and |
| * then uses `ngRepeat` to display every person: |
| <example module="ngAnimate" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| <div ng-init="friends = [ |
| {name:'John', age:25, gender:'boy'}, |
| {name:'Jessie', age:30, gender:'girl'}, |
| {name:'Johanna', age:28, gender:'girl'}, |
| {name:'Joy', age:15, gender:'girl'}, |
| {name:'Mary', age:28, gender:'girl'}, |
| {name:'Peter', age:95, gender:'boy'}, |
| {name:'Sebastian', age:50, gender:'boy'}, |
| {name:'Erika', age:27, gender:'girl'}, |
| {name:'Patrick', age:40, gender:'boy'}, |
| {name:'Samantha', age:60, gender:'girl'} |
| ]"> |
| I have {{friends.length}} friends. They are: |
| <input type="search" ng-model="q" placeholder="filter friends..." aria-label="filter friends" /> |
| <ul class="example-animate-container"> |
| <li class="animate-repeat" ng-repeat="friend in friends | filter:q as results"> |
| [{{$index + 1}}] {{friend.name}} who is {{friend.age}} years old. |
| </li> |
| <li class="animate-repeat" ng-if="results.length == 0"> |
| <strong>No results found...</strong> |
| </li> |
| </ul> |
| </div> |
| </file> |
| <file name="animations.css"> |
| .example-animate-container { |
| background:white; |
| border:1px solid black; |
| list-style:none; |
| margin:0; |
| padding:0 10px; |
| } |
| |
| .animate-repeat { |
| line-height:40px; |
| list-style:none; |
| box-sizing:border-box; |
| } |
| |
| .animate-repeat.ng-move, |
| .animate-repeat.ng-enter, |
| .animate-repeat.ng-leave { |
| transition:all linear 0.5s; |
| } |
| |
| .animate-repeat.ng-leave.ng-leave-active, |
| .animate-repeat.ng-move, |
| .animate-repeat.ng-enter { |
| opacity:0; |
| max-height:0; |
| } |
| |
| .animate-repeat.ng-leave, |
| .animate-repeat.ng-move.ng-move-active, |
| .animate-repeat.ng-enter.ng-enter-active { |
| opacity:1; |
| max-height:40px; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var friends = element.all(by.repeater('friend in friends')); |
| |
| it('should render initial data set', function() { |
| expect(friends.count()).toBe(10); |
| expect(friends.get(0).getText()).toEqual('[1] John who is 25 years old.'); |
| expect(friends.get(1).getText()).toEqual('[2] Jessie who is 30 years old.'); |
| expect(friends.last().getText()).toEqual('[10] Samantha who is 60 years old.'); |
| expect(element(by.binding('friends.length')).getText()) |
| .toMatch("I have 10 friends. They are:"); |
| }); |
| |
| it('should update repeater when filter predicate changes', function() { |
| expect(friends.count()).toBe(10); |
| |
| element(by.model('q')).sendKeys('ma'); |
| |
| expect(friends.count()).toBe(2); |
| expect(friends.get(0).getText()).toEqual('[1] Mary who is 28 years old.'); |
| expect(friends.last().getText()).toEqual('[2] Samantha who is 60 years old.'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngRepeatDirective = ['$parse', '$animate', function($parse, $animate) { |
| var NG_REMOVED = '$$NG_REMOVED'; |
| var ngRepeatMinErr = minErr('ngRepeat'); |
| |
| var updateScope = function(scope, index, valueIdentifier, value, keyIdentifier, key, arrayLength) { |
| // TODO(perf): generate setters to shave off ~40ms or 1-1.5% |
| scope[valueIdentifier] = value; |
| if (keyIdentifier) scope[keyIdentifier] = key; |
| scope.$index = index; |
| scope.$first = (index === 0); |
| scope.$last = (index === (arrayLength - 1)); |
| scope.$middle = !(scope.$first || scope.$last); |
| // jshint bitwise: false |
| scope.$odd = !(scope.$even = (index&1) === 0); |
| // jshint bitwise: true |
| }; |
| |
| var getBlockStart = function(block) { |
| return block.clone[0]; |
| }; |
| |
| var getBlockEnd = function(block) { |
| return block.clone[block.clone.length - 1]; |
| }; |
| |
| |
| return { |
| restrict: 'A', |
| multiElement: true, |
| transclude: 'element', |
| priority: 1000, |
| terminal: true, |
| $$tlb: true, |
| compile: function ngRepeatCompile($element, $attr) { |
| var expression = $attr.ngRepeat; |
| var ngRepeatEndComment = document.createComment(' end ngRepeat: ' + expression + ' '); |
| |
| var match = expression.match(/^\s*([\s\S]+?)\s+in\s+([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+track\s+by\s+([\s\S]+?))?\s*$/); |
| |
| if (!match) { |
| throw ngRepeatMinErr('iexp', "Expected expression in form of '_item_ in _collection_[ track by _id_]' but got '{0}'.", |
| expression); |
| } |
| |
| var lhs = match[1]; |
| var rhs = match[2]; |
| var aliasAs = match[3]; |
| var trackByExp = match[4]; |
| |
| match = lhs.match(/^(?:(\s*[\$\w]+)|\(\s*([\$\w]+)\s*,\s*([\$\w]+)\s*\))$/); |
| |
| if (!match) { |
| throw ngRepeatMinErr('iidexp', "'_item_' in '_item_ in _collection_' should be an identifier or '(_key_, _value_)' expression, but got '{0}'.", |
| lhs); |
| } |
| var valueIdentifier = match[3] || match[1]; |
| var keyIdentifier = match[2]; |
| |
| if (aliasAs && (!/^[$a-zA-Z_][$a-zA-Z0-9_]*$/.test(aliasAs) || |
| /^(null|undefined|this|\$index|\$first|\$middle|\$last|\$even|\$odd|\$parent|\$root|\$id)$/.test(aliasAs))) { |
| throw ngRepeatMinErr('badident', "alias '{0}' is invalid --- must be a valid JS identifier which is not a reserved name.", |
| aliasAs); |
| } |
| |
| var trackByExpGetter, trackByIdExpFn, trackByIdArrayFn, trackByIdObjFn; |
| var hashFnLocals = {$id: hashKey}; |
| |
| if (trackByExp) { |
| trackByExpGetter = $parse(trackByExp); |
| } else { |
| trackByIdArrayFn = function(key, value) { |
| return hashKey(value); |
| }; |
| trackByIdObjFn = function(key) { |
| return key; |
| }; |
| } |
| |
| return function ngRepeatLink($scope, $element, $attr, ctrl, $transclude) { |
| |
| if (trackByExpGetter) { |
| trackByIdExpFn = function(key, value, index) { |
| // assign key, value, and $index to the locals so that they can be used in hash functions |
| if (keyIdentifier) hashFnLocals[keyIdentifier] = key; |
| hashFnLocals[valueIdentifier] = value; |
| hashFnLocals.$index = index; |
| return trackByExpGetter($scope, hashFnLocals); |
| }; |
| } |
| |
| // Store a list of elements from previous run. This is a hash where key is the item from the |
| // iterator, and the value is objects with following properties. |
| // - scope: bound scope |
| // - element: previous element. |
| // - index: position |
| // |
| // We are using no-proto object so that we don't need to guard against inherited props via |
| // hasOwnProperty. |
| var lastBlockMap = createMap(); |
| |
| //watch props |
| $scope.$watchCollection(rhs, function ngRepeatAction(collection) { |
| var index, length, |
| previousNode = $element[0], // node that cloned nodes should be inserted after |
| // initialized to the comment node anchor |
| nextNode, |
| // Same as lastBlockMap but it has the current state. It will become the |
| // lastBlockMap on the next iteration. |
| nextBlockMap = createMap(), |
| collectionLength, |
| key, value, // key/value of iteration |
| trackById, |
| trackByIdFn, |
| collectionKeys, |
| block, // last object information {scope, element, id} |
| nextBlockOrder, |
| elementsToRemove; |
| |
| if (aliasAs) { |
| $scope[aliasAs] = collection; |
| } |
| |
| if (isArrayLike(collection)) { |
| collectionKeys = collection; |
| trackByIdFn = trackByIdExpFn || trackByIdArrayFn; |
| } else { |
| trackByIdFn = trackByIdExpFn || trackByIdObjFn; |
| // if object, extract keys, in enumeration order, unsorted |
| collectionKeys = []; |
| for (var itemKey in collection) { |
| if (hasOwnProperty.call(collection, itemKey) && itemKey.charAt(0) !== '$') { |
| collectionKeys.push(itemKey); |
| } |
| } |
| } |
| |
| collectionLength = collectionKeys.length; |
| nextBlockOrder = new Array(collectionLength); |
| |
| // locate existing items |
| for (index = 0; index < collectionLength; index++) { |
| key = (collection === collectionKeys) ? index : collectionKeys[index]; |
| value = collection[key]; |
| trackById = trackByIdFn(key, value, index); |
| if (lastBlockMap[trackById]) { |
| // found previously seen block |
| block = lastBlockMap[trackById]; |
| delete lastBlockMap[trackById]; |
| nextBlockMap[trackById] = block; |
| nextBlockOrder[index] = block; |
| } else if (nextBlockMap[trackById]) { |
| // if collision detected. restore lastBlockMap and throw an error |
| forEach(nextBlockOrder, function(block) { |
| if (block && block.scope) lastBlockMap[block.id] = block; |
| }); |
| throw ngRepeatMinErr('dupes', |
| "Duplicates in a repeater are not allowed. Use 'track by' expression to specify unique keys. Repeater: {0}, Duplicate key: {1}, Duplicate value: {2}", |
| expression, trackById, value); |
| } else { |
| // new never before seen block |
| nextBlockOrder[index] = {id: trackById, scope: undefined, clone: undefined}; |
| nextBlockMap[trackById] = true; |
| } |
| } |
| |
| // remove leftover items |
| for (var blockKey in lastBlockMap) { |
| block = lastBlockMap[blockKey]; |
| elementsToRemove = getBlockNodes(block.clone); |
| $animate.leave(elementsToRemove); |
| if (elementsToRemove[0].parentNode) { |
| // if the element was not removed yet because of pending animation, mark it as deleted |
| // so that we can ignore it later |
| for (index = 0, length = elementsToRemove.length; index < length; index++) { |
| elementsToRemove[index][NG_REMOVED] = true; |
| } |
| } |
| block.scope.$destroy(); |
| } |
| |
| // we are not using forEach for perf reasons (trying to avoid #call) |
| for (index = 0; index < collectionLength; index++) { |
| key = (collection === collectionKeys) ? index : collectionKeys[index]; |
| value = collection[key]; |
| block = nextBlockOrder[index]; |
| |
| if (block.scope) { |
| // if we have already seen this object, then we need to reuse the |
| // associated scope/element |
| |
| nextNode = previousNode; |
| |
| // skip nodes that are already pending removal via leave animation |
| do { |
| nextNode = nextNode.nextSibling; |
| } while (nextNode && nextNode[NG_REMOVED]); |
| |
| if (getBlockStart(block) != nextNode) { |
| // existing item which got moved |
| $animate.move(getBlockNodes(block.clone), null, jqLite(previousNode)); |
| } |
| previousNode = getBlockEnd(block); |
| updateScope(block.scope, index, valueIdentifier, value, keyIdentifier, key, collectionLength); |
| } else { |
| // new item which we don't know about |
| $transclude(function ngRepeatTransclude(clone, scope) { |
| block.scope = scope; |
| // http://jsperf.com/clone-vs-createcomment |
| var endNode = ngRepeatEndComment.cloneNode(false); |
| clone[clone.length++] = endNode; |
| |
| // TODO(perf): support naked previousNode in `enter` to avoid creation of jqLite wrapper? |
| $animate.enter(clone, null, jqLite(previousNode)); |
| previousNode = endNode; |
| // Note: We only need the first/last node of the cloned nodes. |
| // However, we need to keep the reference to the jqlite wrapper as it might be changed later |
| // by a directive with templateUrl when its template arrives. |
| block.clone = clone; |
| nextBlockMap[block.id] = block; |
| updateScope(block.scope, index, valueIdentifier, value, keyIdentifier, key, collectionLength); |
| }); |
| } |
| } |
| lastBlockMap = nextBlockMap; |
| }); |
| }; |
| } |
| }; |
| }]; |
| |
| var NG_HIDE_CLASS = 'ng-hide'; |
| var NG_HIDE_IN_PROGRESS_CLASS = 'ng-hide-animate'; |
| /** |
| * @ngdoc directive |
| * @name ngShow |
| * @multiElement |
| * |
| * @description |
| * The `ngShow` directive shows or hides the given HTML element based on the expression |
| * provided to the `ngShow` attribute. The element is shown or hidden by removing or adding |
| * the `.ng-hide` CSS class onto the element. The `.ng-hide` CSS class is predefined |
| * in AngularJS and sets the display style to none (using an !important flag). |
| * For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}). |
| * |
| * ```html |
| * <!-- when $scope.myValue is truthy (element is visible) --> |
| * <div ng-show="myValue"></div> |
| * |
| * <!-- when $scope.myValue is falsy (element is hidden) --> |
| * <div ng-show="myValue" class="ng-hide"></div> |
| * ``` |
| * |
| * When the `ngShow` expression evaluates to a falsy value then the `.ng-hide` CSS class is added to the class |
| * attribute on the element causing it to become hidden. When truthy, the `.ng-hide` CSS class is removed |
| * from the element causing the element not to appear hidden. |
| * |
| * ## Why is !important used? |
| * |
| * You may be wondering why !important is used for the `.ng-hide` CSS class. This is because the `.ng-hide` selector |
| * can be easily overridden by heavier selectors. For example, something as simple |
| * as changing the display style on a HTML list item would make hidden elements appear visible. |
| * This also becomes a bigger issue when dealing with CSS frameworks. |
| * |
| * By using !important, the show and hide behavior will work as expected despite any clash between CSS selector |
| * specificity (when !important isn't used with any conflicting styles). If a developer chooses to override the |
| * styling to change how to hide an element then it is just a matter of using !important in their own CSS code. |
| * |
| * ### Overriding `.ng-hide` |
| * |
| * By default, the `.ng-hide` class will style the element with `display: none!important`. If you wish to change |
| * the hide behavior with ngShow/ngHide then this can be achieved by restating the styles for the `.ng-hide` |
| * class CSS. Note that the selector that needs to be used is actually `.ng-hide:not(.ng-hide-animate)` to cope |
| * with extra animation classes that can be added. |
| * |
| * ```css |
| * .ng-hide:not(.ng-hide-animate) { |
| * /* this is just another form of hiding an element */ |
| * display: block!important; |
| * position: absolute; |
| * top: -9999px; |
| * left: -9999px; |
| * } |
| * ``` |
| * |
| * By default you don't need to override in CSS anything and the animations will work around the display style. |
| * |
| * ## A note about animations with `ngShow` |
| * |
| * Animations in ngShow/ngHide work with the show and hide events that are triggered when the directive expression |
| * is true and false. This system works like the animation system present with ngClass except that |
| * you must also include the !important flag to override the display property |
| * so that you can perform an animation when the element is hidden during the time of the animation. |
| * |
| * ```css |
| * // |
| * //a working example can be found at the bottom of this page |
| * // |
| * .my-element.ng-hide-add, .my-element.ng-hide-remove { |
| * /* this is required as of 1.3x to properly |
| * apply all styling in a show/hide animation */ |
| * transition: 0s linear all; |
| * } |
| * |
| * .my-element.ng-hide-add-active, |
| * .my-element.ng-hide-remove-active { |
| * /* the transition is defined in the active class */ |
| * transition: 1s linear all; |
| * } |
| * |
| * .my-element.ng-hide-add { ... } |
| * .my-element.ng-hide-add.ng-hide-add-active { ... } |
| * .my-element.ng-hide-remove { ... } |
| * .my-element.ng-hide-remove.ng-hide-remove-active { ... } |
| * ``` |
| * |
| * Keep in mind that, as of AngularJS version 1.3.0-beta.11, there is no need to change the display |
| * property to block during animation states--ngAnimate will handle the style toggling automatically for you. |
| * |
| * @animations |
| * addClass: `.ng-hide` - happens after the `ngShow` expression evaluates to a truthy value and the just before contents are set to visible |
| * removeClass: `.ng-hide` - happens after the `ngShow` expression evaluates to a non truthy value and just before the contents are set to hidden |
| * |
| * @element ANY |
| * @param {expression} ngShow If the {@link guide/expression expression} is truthy |
| * then the element is shown or hidden respectively. |
| * |
| * @example |
| <example module="ngAnimate" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| Click me: <input type="checkbox" ng-model="checked" aria-label="Toggle ngHide"><br/> |
| <div> |
| Show: |
| <div class="check-element animate-show" ng-show="checked"> |
| <span class="glyphicon glyphicon-thumbs-up"></span> I show up when your checkbox is checked. |
| </div> |
| </div> |
| <div> |
| Hide: |
| <div class="check-element animate-show" ng-hide="checked"> |
| <span class="glyphicon glyphicon-thumbs-down"></span> I hide when your checkbox is checked. |
| </div> |
| </div> |
| </file> |
| <file name="glyphicons.css"> |
| @import url(../../components/bootstrap-3.1.1/css/bootstrap.css); |
| </file> |
| <file name="animations.css"> |
| .animate-show { |
| line-height: 20px; |
| opacity: 1; |
| padding: 10px; |
| border: 1px solid black; |
| background: white; |
| } |
| |
| .animate-show.ng-hide-add, .animate-show.ng-hide-remove { |
| transition: all linear 0.5s; |
| } |
| |
| .animate-show.ng-hide { |
| line-height: 0; |
| opacity: 0; |
| padding: 0 10px; |
| } |
| |
| .check-element { |
| padding: 10px; |
| border: 1px solid black; |
| background: white; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var thumbsUp = element(by.css('span.glyphicon-thumbs-up')); |
| var thumbsDown = element(by.css('span.glyphicon-thumbs-down')); |
| |
| it('should check ng-show / ng-hide', function() { |
| expect(thumbsUp.isDisplayed()).toBeFalsy(); |
| expect(thumbsDown.isDisplayed()).toBeTruthy(); |
| |
| element(by.model('checked')).click(); |
| |
| expect(thumbsUp.isDisplayed()).toBeTruthy(); |
| expect(thumbsDown.isDisplayed()).toBeFalsy(); |
| }); |
| </file> |
| </example> |
| */ |
| var ngShowDirective = ['$animate', function($animate) { |
| return { |
| restrict: 'A', |
| multiElement: true, |
| link: function(scope, element, attr) { |
| scope.$watch(attr.ngShow, function ngShowWatchAction(value) { |
| // we're adding a temporary, animation-specific class for ng-hide since this way |
| // we can control when the element is actually displayed on screen without having |
| // to have a global/greedy CSS selector that breaks when other animations are run. |
| // Read: https://github.com/angular/angular.js/issues/9103#issuecomment-58335845 |
| $animate[value ? 'removeClass' : 'addClass'](element, NG_HIDE_CLASS, { |
| tempClasses: NG_HIDE_IN_PROGRESS_CLASS |
| }); |
| }); |
| } |
| }; |
| }]; |
| |
| |
| /** |
| * @ngdoc directive |
| * @name ngHide |
| * @multiElement |
| * |
| * @description |
| * The `ngHide` directive shows or hides the given HTML element based on the expression |
| * provided to the `ngHide` attribute. The element is shown or hidden by removing or adding |
| * the `ng-hide` CSS class onto the element. The `.ng-hide` CSS class is predefined |
| * in AngularJS and sets the display style to none (using an !important flag). |
| * For CSP mode please add `angular-csp.css` to your html file (see {@link ng.directive:ngCsp ngCsp}). |
| * |
| * ```html |
| * <!-- when $scope.myValue is truthy (element is hidden) --> |
| * <div ng-hide="myValue" class="ng-hide"></div> |
| * |
| * <!-- when $scope.myValue is falsy (element is visible) --> |
| * <div ng-hide="myValue"></div> |
| * ``` |
| * |
| * When the `ngHide` expression evaluates to a truthy value then the `.ng-hide` CSS class is added to the class |
| * attribute on the element causing it to become hidden. When falsy, the `.ng-hide` CSS class is removed |
| * from the element causing the element not to appear hidden. |
| * |
| * ## Why is !important used? |
| * |
| * You may be wondering why !important is used for the `.ng-hide` CSS class. This is because the `.ng-hide` selector |
| * can be easily overridden by heavier selectors. For example, something as simple |
| * as changing the display style on a HTML list item would make hidden elements appear visible. |
| * This also becomes a bigger issue when dealing with CSS frameworks. |
| * |
| * By using !important, the show and hide behavior will work as expected despite any clash between CSS selector |
| * specificity (when !important isn't used with any conflicting styles). If a developer chooses to override the |
| * styling to change how to hide an element then it is just a matter of using !important in their own CSS code. |
| * |
| * ### Overriding `.ng-hide` |
| * |
| * By default, the `.ng-hide` class will style the element with `display: none!important`. If you wish to change |
| * the hide behavior with ngShow/ngHide then this can be achieved by restating the styles for the `.ng-hide` |
| * class in CSS: |
| * |
| * ```css |
| * .ng-hide { |
| * /* this is just another form of hiding an element */ |
| * display: block!important; |
| * position: absolute; |
| * top: -9999px; |
| * left: -9999px; |
| * } |
| * ``` |
| * |
| * By default you don't need to override in CSS anything and the animations will work around the display style. |
| * |
| * ## A note about animations with `ngHide` |
| * |
| * Animations in ngShow/ngHide work with the show and hide events that are triggered when the directive expression |
| * is true and false. This system works like the animation system present with ngClass, except that the `.ng-hide` |
| * CSS class is added and removed for you instead of your own CSS class. |
| * |
| * ```css |
| * // |
| * //a working example can be found at the bottom of this page |
| * // |
| * .my-element.ng-hide-add, .my-element.ng-hide-remove { |
| * transition: 0.5s linear all; |
| * } |
| * |
| * .my-element.ng-hide-add { ... } |
| * .my-element.ng-hide-add.ng-hide-add-active { ... } |
| * .my-element.ng-hide-remove { ... } |
| * .my-element.ng-hide-remove.ng-hide-remove-active { ... } |
| * ``` |
| * |
| * Keep in mind that, as of AngularJS version 1.3.0-beta.11, there is no need to change the display |
| * property to block during animation states--ngAnimate will handle the style toggling automatically for you. |
| * |
| * @animations |
| * removeClass: `.ng-hide` - happens after the `ngHide` expression evaluates to a truthy value and just before the contents are set to hidden |
| * addClass: `.ng-hide` - happens after the `ngHide` expression evaluates to a non truthy value and just before the contents are set to visible |
| * |
| * @element ANY |
| * @param {expression} ngHide If the {@link guide/expression expression} is truthy then |
| * the element is shown or hidden respectively. |
| * |
| * @example |
| <example module="ngAnimate" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| Click me: <input type="checkbox" ng-model="checked" aria-label="Toggle ngShow"><br/> |
| <div> |
| Show: |
| <div class="check-element animate-hide" ng-show="checked"> |
| <span class="glyphicon glyphicon-thumbs-up"></span> I show up when your checkbox is checked. |
| </div> |
| </div> |
| <div> |
| Hide: |
| <div class="check-element animate-hide" ng-hide="checked"> |
| <span class="glyphicon glyphicon-thumbs-down"></span> I hide when your checkbox is checked. |
| </div> |
| </div> |
| </file> |
| <file name="glyphicons.css"> |
| @import url(../../components/bootstrap-3.1.1/css/bootstrap.css); |
| </file> |
| <file name="animations.css"> |
| .animate-hide { |
| transition: all linear 0.5s; |
| line-height: 20px; |
| opacity: 1; |
| padding: 10px; |
| border: 1px solid black; |
| background: white; |
| } |
| |
| .animate-hide.ng-hide { |
| line-height: 0; |
| opacity: 0; |
| padding: 0 10px; |
| } |
| |
| .check-element { |
| padding: 10px; |
| border: 1px solid black; |
| background: white; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var thumbsUp = element(by.css('span.glyphicon-thumbs-up')); |
| var thumbsDown = element(by.css('span.glyphicon-thumbs-down')); |
| |
| it('should check ng-show / ng-hide', function() { |
| expect(thumbsUp.isDisplayed()).toBeFalsy(); |
| expect(thumbsDown.isDisplayed()).toBeTruthy(); |
| |
| element(by.model('checked')).click(); |
| |
| expect(thumbsUp.isDisplayed()).toBeTruthy(); |
| expect(thumbsDown.isDisplayed()).toBeFalsy(); |
| }); |
| </file> |
| </example> |
| */ |
| var ngHideDirective = ['$animate', function($animate) { |
| return { |
| restrict: 'A', |
| multiElement: true, |
| link: function(scope, element, attr) { |
| scope.$watch(attr.ngHide, function ngHideWatchAction(value) { |
| // The comment inside of the ngShowDirective explains why we add and |
| // remove a temporary class for the show/hide animation |
| $animate[value ? 'addClass' : 'removeClass'](element,NG_HIDE_CLASS, { |
| tempClasses: NG_HIDE_IN_PROGRESS_CLASS |
| }); |
| }); |
| } |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name ngStyle |
| * @restrict AC |
| * |
| * @description |
| * The `ngStyle` directive allows you to set CSS style on an HTML element conditionally. |
| * |
| * @element ANY |
| * @param {expression} ngStyle |
| * |
| * {@link guide/expression Expression} which evals to an |
| * object whose keys are CSS style names and values are corresponding values for those CSS |
| * keys. |
| * |
| * Since some CSS style names are not valid keys for an object, they must be quoted. |
| * See the 'background-color' style in the example below. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <input type="button" value="set color" ng-click="myStyle={color:'red'}"> |
| <input type="button" value="set background" ng-click="myStyle={'background-color':'blue'}"> |
| <input type="button" value="clear" ng-click="myStyle={}"> |
| <br/> |
| <span ng-style="myStyle">Sample Text</span> |
| <pre>myStyle={{myStyle}}</pre> |
| </file> |
| <file name="style.css"> |
| span { |
| color: black; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var colorSpan = element(by.css('span')); |
| |
| it('should check ng-style', function() { |
| expect(colorSpan.getCssValue('color')).toBe('rgba(0, 0, 0, 1)'); |
| element(by.css('input[value=\'set color\']')).click(); |
| expect(colorSpan.getCssValue('color')).toBe('rgba(255, 0, 0, 1)'); |
| element(by.css('input[value=clear]')).click(); |
| expect(colorSpan.getCssValue('color')).toBe('rgba(0, 0, 0, 1)'); |
| }); |
| </file> |
| </example> |
| */ |
| var ngStyleDirective = ngDirective(function(scope, element, attr) { |
| scope.$watch(attr.ngStyle, function ngStyleWatchAction(newStyles, oldStyles) { |
| if (oldStyles && (newStyles !== oldStyles)) { |
| forEach(oldStyles, function(val, style) { element.css(style, '');}); |
| } |
| if (newStyles) element.css(newStyles); |
| }, true); |
| }); |
| |
| /** |
| * @ngdoc directive |
| * @name ngSwitch |
| * @restrict EA |
| * |
| * @description |
| * The `ngSwitch` directive is used to conditionally swap DOM structure on your template based on a scope expression. |
| * Elements within `ngSwitch` but without `ngSwitchWhen` or `ngSwitchDefault` directives will be preserved at the location |
| * as specified in the template. |
| * |
| * The directive itself works similar to ngInclude, however, instead of downloading template code (or loading it |
| * from the template cache), `ngSwitch` simply chooses one of the nested elements and makes it visible based on which element |
| * matches the value obtained from the evaluated expression. In other words, you define a container element |
| * (where you place the directive), place an expression on the **`on="..."` attribute** |
| * (or the **`ng-switch="..."` attribute**), define any inner elements inside of the directive and place |
| * a when attribute per element. The when attribute is used to inform ngSwitch which element to display when the on |
| * expression is evaluated. If a matching expression is not found via a when attribute then an element with the default |
| * attribute is displayed. |
| * |
| * <div class="alert alert-info"> |
| * Be aware that the attribute values to match against cannot be expressions. They are interpreted |
| * as literal string values to match against. |
| * For example, **`ng-switch-when="someVal"`** will match against the string `"someVal"` not against the |
| * value of the expression `$scope.someVal`. |
| * </div> |
| |
| * @animations |
| * enter - happens after the ngSwitch contents change and the matched child element is placed inside the container |
| * leave - happens just after the ngSwitch contents change and just before the former contents are removed from the DOM |
| * |
| * @usage |
| * |
| * ``` |
| * <ANY ng-switch="expression"> |
| * <ANY ng-switch-when="matchValue1">...</ANY> |
| * <ANY ng-switch-when="matchValue2">...</ANY> |
| * <ANY ng-switch-default>...</ANY> |
| * </ANY> |
| * ``` |
| * |
| * |
| * @scope |
| * @priority 1200 |
| * @param {*} ngSwitch|on expression to match against <code>ng-switch-when</code>. |
| * On child elements add: |
| * |
| * * `ngSwitchWhen`: the case statement to match against. If match then this |
| * case will be displayed. If the same match appears multiple times, all the |
| * elements will be displayed. |
| * * `ngSwitchDefault`: the default case when no other case match. If there |
| * are multiple default cases, all of them will be displayed when no other |
| * case match. |
| * |
| * |
| * @example |
| <example module="switchExample" deps="angular-animate.js" animations="true"> |
| <file name="index.html"> |
| <div ng-controller="ExampleController"> |
| <select ng-model="selection" ng-options="item for item in items"> |
| </select> |
| <code>selection={{selection}}</code> |
| <hr/> |
| <div class="animate-switch-container" |
| ng-switch on="selection"> |
| <div class="animate-switch" ng-switch-when="settings">Settings Div</div> |
| <div class="animate-switch" ng-switch-when="home">Home Span</div> |
| <div class="animate-switch" ng-switch-default>default</div> |
| </div> |
| </div> |
| </file> |
| <file name="script.js"> |
| angular.module('switchExample', ['ngAnimate']) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.items = ['settings', 'home', 'other']; |
| $scope.selection = $scope.items[0]; |
| }]); |
| </file> |
| <file name="animations.css"> |
| .animate-switch-container { |
| position:relative; |
| background:white; |
| border:1px solid black; |
| height:40px; |
| overflow:hidden; |
| } |
| |
| .animate-switch { |
| padding:10px; |
| } |
| |
| .animate-switch.ng-animate { |
| transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s; |
| |
| position:absolute; |
| top:0; |
| left:0; |
| right:0; |
| bottom:0; |
| } |
| |
| .animate-switch.ng-leave.ng-leave-active, |
| .animate-switch.ng-enter { |
| top:-50px; |
| } |
| .animate-switch.ng-leave, |
| .animate-switch.ng-enter.ng-enter-active { |
| top:0; |
| } |
| </file> |
| <file name="protractor.js" type="protractor"> |
| var switchElem = element(by.css('[ng-switch]')); |
| var select = element(by.model('selection')); |
| |
| it('should start in settings', function() { |
| expect(switchElem.getText()).toMatch(/Settings Div/); |
| }); |
| it('should change to home', function() { |
| select.all(by.css('option')).get(1).click(); |
| expect(switchElem.getText()).toMatch(/Home Span/); |
| }); |
| it('should select default', function() { |
| select.all(by.css('option')).get(2).click(); |
| expect(switchElem.getText()).toMatch(/default/); |
| }); |
| </file> |
| </example> |
| */ |
| var ngSwitchDirective = ['$animate', function($animate) { |
| return { |
| require: 'ngSwitch', |
| |
| // asks for $scope to fool the BC controller module |
| controller: ['$scope', function ngSwitchController() { |
| this.cases = {}; |
| }], |
| link: function(scope, element, attr, ngSwitchController) { |
| var watchExpr = attr.ngSwitch || attr.on, |
| selectedTranscludes = [], |
| selectedElements = [], |
| previousLeaveAnimations = [], |
| selectedScopes = []; |
| |
| var spliceFactory = function(array, index) { |
| return function() { array.splice(index, 1); }; |
| }; |
| |
| scope.$watch(watchExpr, function ngSwitchWatchAction(value) { |
| var i, ii; |
| for (i = 0, ii = previousLeaveAnimations.length; i < ii; ++i) { |
| $animate.cancel(previousLeaveAnimations[i]); |
| } |
| previousLeaveAnimations.length = 0; |
| |
| for (i = 0, ii = selectedScopes.length; i < ii; ++i) { |
| var selected = getBlockNodes(selectedElements[i].clone); |
| selectedScopes[i].$destroy(); |
| var promise = previousLeaveAnimations[i] = $animate.leave(selected); |
| promise.then(spliceFactory(previousLeaveAnimations, i)); |
| } |
| |
| selectedElements.length = 0; |
| selectedScopes.length = 0; |
| |
| if ((selectedTranscludes = ngSwitchController.cases['!' + value] || ngSwitchController.cases['?'])) { |
| forEach(selectedTranscludes, function(selectedTransclude) { |
| selectedTransclude.transclude(function(caseElement, selectedScope) { |
| selectedScopes.push(selectedScope); |
| var anchor = selectedTransclude.element; |
| caseElement[caseElement.length++] = document.createComment(' end ngSwitchWhen: '); |
| var block = { clone: caseElement }; |
| |
| selectedElements.push(block); |
| $animate.enter(caseElement, anchor.parent(), anchor); |
| }); |
| }); |
| } |
| }); |
| } |
| }; |
| }]; |
| |
| var ngSwitchWhenDirective = ngDirective({ |
| transclude: 'element', |
| priority: 1200, |
| require: '^ngSwitch', |
| multiElement: true, |
| link: function(scope, element, attrs, ctrl, $transclude) { |
| ctrl.cases['!' + attrs.ngSwitchWhen] = (ctrl.cases['!' + attrs.ngSwitchWhen] || []); |
| ctrl.cases['!' + attrs.ngSwitchWhen].push({ transclude: $transclude, element: element }); |
| } |
| }); |
| |
| var ngSwitchDefaultDirective = ngDirective({ |
| transclude: 'element', |
| priority: 1200, |
| require: '^ngSwitch', |
| multiElement: true, |
| link: function(scope, element, attr, ctrl, $transclude) { |
| ctrl.cases['?'] = (ctrl.cases['?'] || []); |
| ctrl.cases['?'].push({ transclude: $transclude, element: element }); |
| } |
| }); |
| |
| /** |
| * @ngdoc directive |
| * @name ngTransclude |
| * @restrict EAC |
| * |
| * @description |
| * Directive that marks the insertion point for the transcluded DOM of the nearest parent directive that uses transclusion. |
| * |
| * Any existing content of the element that this directive is placed on will be removed before the transcluded content is inserted. |
| * |
| * @element ANY |
| * |
| * @example |
| <example module="transcludeExample"> |
| <file name="index.html"> |
| <script> |
| angular.module('transcludeExample', []) |
| .directive('pane', function(){ |
| return { |
| restrict: 'E', |
| transclude: true, |
| scope: { title:'@' }, |
| template: '<div style="border: 1px solid black;">' + |
| '<div style="background-color: gray">{{title}}</div>' + |
| '<ng-transclude></ng-transclude>' + |
| '</div>' |
| }; |
| }) |
| .controller('ExampleController', ['$scope', function($scope) { |
| $scope.title = 'Lorem Ipsum'; |
| $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...'; |
| }]); |
| </script> |
| <div ng-controller="ExampleController"> |
| <input ng-model="title" aria-label="title"> <br/> |
| <textarea ng-model="text" aria-label="text"></textarea> <br/> |
| <pane title="{{title}}">{{text}}</pane> |
| </div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should have transcluded', function() { |
| var titleElement = element(by.model('title')); |
| titleElement.clear(); |
| titleElement.sendKeys('TITLE'); |
| var textElement = element(by.model('text')); |
| textElement.clear(); |
| textElement.sendKeys('TEXT'); |
| expect(element(by.binding('title')).getText()).toEqual('TITLE'); |
| expect(element(by.binding('text')).getText()).toEqual('TEXT'); |
| }); |
| </file> |
| </example> |
| * |
| */ |
| var ngTranscludeDirective = ngDirective({ |
| restrict: 'EAC', |
| link: function($scope, $element, $attrs, controller, $transclude) { |
| if (!$transclude) { |
| throw minErr('ngTransclude')('orphan', |
| 'Illegal use of ngTransclude directive in the template! ' + |
| 'No parent directive that requires a transclusion found. ' + |
| 'Element: {0}', |
| startingTag($element)); |
| } |
| |
| $transclude(function(clone) { |
| $element.empty(); |
| $element.append(clone); |
| }); |
| } |
| }); |
| |
| /** |
| * @ngdoc directive |
| * @name script |
| * @restrict E |
| * |
| * @description |
| * Load the content of a `<script>` element into {@link ng.$templateCache `$templateCache`}, so that the |
| * template can be used by {@link ng.directive:ngInclude `ngInclude`}, |
| * {@link ngRoute.directive:ngView `ngView`}, or {@link guide/directive directives}. The type of the |
| * `<script>` element must be specified as `text/ng-template`, and a cache name for the template must be |
| * assigned through the element's `id`, which can then be used as a directive's `templateUrl`. |
| * |
| * @param {string} type Must be set to `'text/ng-template'`. |
| * @param {string} id Cache name of the template. |
| * |
| * @example |
| <example> |
| <file name="index.html"> |
| <script type="text/ng-template" id="/tpl.html"> |
| Content of the template. |
| </script> |
| |
| <a ng-click="currentTpl='/tpl.html'" id="tpl-link">Load inlined template</a> |
| <div id="tpl-content" ng-include src="currentTpl"></div> |
| </file> |
| <file name="protractor.js" type="protractor"> |
| it('should load template defined inside script tag', function() { |
| element(by.css('#tpl-link')).click(); |
| expect(element(by.css('#tpl-content')).getText()).toMatch(/Content of the template/); |
| }); |
| </file> |
| </example> |
| */ |
| var scriptDirective = ['$templateCache', function($templateCache) { |
| return { |
| restrict: 'E', |
| terminal: true, |
| compile: function(element, attr) { |
| if (attr.type == 'text/ng-template') { |
| var templateUrl = attr.id, |
| text = element[0].text; |
| |
| $templateCache.put(templateUrl, text); |
| } |
| } |
| }; |
| }]; |
| |
| var noopNgModelController = { $setViewValue: noop, $render: noop }; |
| |
| /** |
| * @ngdoc type |
| * @name select.SelectController |
| * @description |
| * The controller for the `<select>` directive. This provides support for reading |
| * and writing the selected value(s) of the control and also coordinates dynamically |
| * added `<option>` elements, perhaps by an `ngRepeat` directive. |
| */ |
| var SelectController = |
| ['$element', '$scope', '$attrs', function($element, $scope, $attrs) { |
| |
| var self = this, |
| optionsMap = new HashMap(); |
| |
| // If the ngModel doesn't get provided then provide a dummy noop version to prevent errors |
| self.ngModelCtrl = noopNgModelController; |
| |
| // The "unknown" option is one that is prepended to the list if the viewValue |
| // does not match any of the options. When it is rendered the value of the unknown |
| // option is '? XXX ?' where XXX is the hashKey of the value that is not known. |
| // |
| // We can't just jqLite('<option>') since jqLite is not smart enough |
| // to create it in <select> and IE barfs otherwise. |
| self.unknownOption = jqLite(document.createElement('option')); |
| self.renderUnknownOption = function(val) { |
| var unknownVal = '? ' + hashKey(val) + ' ?'; |
| self.unknownOption.val(unknownVal); |
| $element.prepend(self.unknownOption); |
| $element.val(unknownVal); |
| }; |
| |
| $scope.$on('$destroy', function() { |
| // disable unknown option so that we don't do work when the whole select is being destroyed |
| self.renderUnknownOption = noop; |
| }); |
| |
| self.removeUnknownOption = function() { |
| if (self.unknownOption.parent()) self.unknownOption.remove(); |
| }; |
| |
| |
| // Read the value of the select control, the implementation of this changes depending |
| // upon whether the select can have multiple values and whether ngOptions is at work. |
| self.readValue = function readSingleValue() { |
| self.removeUnknownOption(); |
| return $element.val(); |
| }; |
| |
| |
| // Write the value to the select control, the implementation of this changes depending |
| // upon whether the select can have multiple values and whether ngOptions is at work. |
| self.writeValue = function writeSingleValue(value) { |
| if (self.hasOption(value)) { |
| self.removeUnknownOption(); |
| $element.val(value); |
| if (value === '') self.emptyOption.prop('selected', true); // to make IE9 happy |
| } else { |
| if (value == null && self.emptyOption) { |
| self.removeUnknownOption(); |
| $element.val(''); |
| } else { |
| self.renderUnknownOption(value); |
| } |
| } |
| }; |
| |
| |
| // Tell the select control that an option, with the given value, has been added |
| self.addOption = function(value, element) { |
| assertNotHasOwnProperty(value, '"option value"'); |
| if (value === '') { |
| self.emptyOption = element; |
| } |
| var count = optionsMap.get(value) || 0; |
| optionsMap.put(value, count + 1); |
| }; |
| |
| // Tell the select control that an option, with the given value, has been removed |
| self.removeOption = function(value) { |
| var count = optionsMap.get(value); |
| if (count) { |
| if (count === 1) { |
| optionsMap.remove(value); |
| if (value === '') { |
| self.emptyOption = undefined; |
| } |
| } else { |
| optionsMap.put(value, count - 1); |
| } |
| } |
| }; |
| |
| // Check whether the select control has an option matching the given value |
| self.hasOption = function(value) { |
| return !!optionsMap.get(value); |
| }; |
| }]; |
| |
| /** |
| * @ngdoc directive |
| * @name select |
| * @restrict E |
| * |
| * @description |
| * HTML `SELECT` element with angular data-binding. |
| * |
| * The `select` directive is used together with {@link ngModel `ngModel`} to provide data-binding |
| * between the scope and the `<select>` control (including setting default values). |
| * Ìt also handles dynamic `<option>` elements, which can be added using the {@link ngRepeat `ngRepeat}` or |
| * {@link ngOptions `ngOptions`} directives. |
| * |
| * When an item in the `<select>` menu is selected, the value of the selected option will be bound |
| * to the model identified by the `ngModel` directive. With static or repeated options, this is |
| * the content of the `value` attribute or the textContent of the `<option>`, if the value attribute is missing. |
| * If you want dynamic value attributes, you can use interpolation inside the value attribute. |
| * |
| * <div class="alert alert-warning"> |
| * Note that the value of a `select` directive used without `ngOptions` is always a string. |
| * When the model needs to be bound to a non-string value, you must either explictly convert it |
| * using a directive (see example below) or use `ngOptions` to specify the set of options. |
| * This is because an option element can only be bound to string values at present. |
| * </div> |
| * |
| * If the viewValue of `ngModel` does not match any of the options, then the control |
| * will automatically add an "unknown" option, which it then removes when the mismatch is resolved. |
| * |
| * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can |
| * be nested into the `<select>` element. This element will then represent the `null` or "not selected" |
| * option. See example below for demonstration. |
| * |
| * <div class="alert alert-info"> |
| * In many cases, `ngRepeat` can be used on `<option>` elements instead of {@link ng.directive:ngOptions |
| * ngOptions} to achieve a similar result. However, `ngOptions` provides some benefits, such as |
| * more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the |
| * comprehension expression, and additionally in reducing memory and increasing speed by not creating |
| * a new scope for each repeated instance. |
| * </div> |
| * |
| * |
| * @param {string} ngModel Assignable angular expression to data-bind to. |
| * @param {string=} name Property name of the form under which the control is published. |
| * @param {string=} required Sets `required` validation error key if the value is not entered. |
| * @param {string=} ngRequired Adds required attribute and required validation constraint to |
| * the element when the ngRequired expression evaluates to true. Use ngRequired instead of required |
| * when you want to data-bind to the required attribute. |
| * @param {string=} ngChange Angular expression to be executed when selected option(s) changes due to user |
| * interaction with the select element. |
| * @param {string=} ngOptions sets the options that the select is populated with and defines what is |
| * set on the model on selection. See {@link ngOptions `ngOptions`}. |
| * |
| * @example |
| * ### Simple `select` elements with static options |
| * |
| * <example name="static-select" module="staticSelect"> |
| * <file name="index.html"> |
| * <div ng-controller="ExampleController"> |
| * <form name="myForm"> |
| * <label for="singleSelect"> Single select: </label><br> |
| * <select name="singleSelect" ng-model="data.singleSelect"> |
| * <option value="option-1">Option 1</option> |
| * <option value="option-2">Option 2</option> |
| * </select><br> |
| * |
| * <label for="singleSelect"> Single select with "not selected" option and dynamic option values: </label><br> |
| * <select name="singleSelect" id="singleSelect" ng-model="data.singleSelect"> |
| * <option value="">---Please select---</option> <!-- not selected / blank option --> |
| * <option value="{{data.option1}}">Option 1</option> <!-- interpolation --> |
| * <option value="option-2">Option 2</option> |
| * </select><br> |
| * <button ng-click="forceUnknownOption()">Force unknown option</button><br> |
| * <tt>singleSelect = {{data.singleSelect}}</tt> |
| * |
| * <hr> |
| * <label for="multipleSelect"> Multiple select: </label><br> |
| * <select name="multipleSelect" id="multipleSelect" ng-model="data.multipleSelect" multiple> |
| * <option value="option-1">Option 1</option> |
| * <option value="option-2">Option 2</option> |
| * <option value="option-3">Option 3</option> |
| * </select><br> |
| * <tt>multipleSelect = {{data.multipleSelect}}</tt><br/> |
| * </form> |
| * </div> |
| * </file> |
| * <file name="app.js"> |
| * angular.module('staticSelect', []) |
| * .controller('ExampleController', ['$scope', function($scope) { |
| * $scope.data = { |
| * singleSelect: null, |
| * multipleSelect: [], |
| * option1: 'option-1', |
| * }; |
| * |
| * $scope.forceUnknownOption = function() { |
| * $scope.data.singleSelect = 'nonsense'; |
| * }; |
| * }]); |
| * </file> |
| *</example> |
| * |
| * ### Using `ngRepeat` to generate `select` options |
| * <example name="ngrepeat-select" module="ngrepeatSelect"> |
| * <file name="index.html"> |
| * <div ng-controller="ExampleController"> |
| * <form name="myForm"> |
| * <label for="repeatSelect"> Repeat select: </label> |
| * <select name="repeatSelect" id="repeatSelect" ng-model="data.repeatSelect"> |
| * <option ng-repeat="option in data.availableOptions" value="{{option.id}}">{{option.name}}</option> |
| * </select> |
| * </form> |
| * <hr> |
| * <tt>repeatSelect = {{data.repeatSelect}}</tt><br/> |
| * </div> |
| * </file> |
| * <file name="app.js"> |
| * angular.module('ngrepeatSelect', []) |
| * .controller('ExampleController', ['$scope', function($scope) { |
| * $scope.data = { |
| * repeatSelect: null, |
| * availableOptions: [ |
| * {id: '1', name: 'Option A'}, |
| * {id: '2', name: 'Option B'}, |
| * {id: '3', name: 'Option C'} |
| * ], |
| * }; |
| * }]); |
| * </file> |
| *</example> |
| * |
| * |
| * ### Using `select` with `ngOptions` and setting a default value |
| * See the {@link ngOptions ngOptions documentation} for more `ngOptions` usage examples. |
| * |
| * <example name="select-with-default-values" module="defaultValueSelect"> |
| * <file name="index.html"> |
| * <div ng-controller="ExampleController"> |
| * <form name="myForm"> |
| * <label for="mySelect">Make a choice:</label> |
| * <select name="mySelect" id="mySelect" |
| * ng-options="option.name for option in data.availableOptions track by option.id" |
| * ng-model="data.selectedOption"></select> |
| * </form> |
| * <hr> |
| * <tt>option = {{data.selectedOption}}</tt><br/> |
| * </div> |
| * </file> |
| * <file name="app.js"> |
| * angular.module('defaultValueSelect', []) |
| * .controller('ExampleController', ['$scope', function($scope) { |
| * $scope.data = { |
| * availableOptions: [ |
| * {id: '1', name: 'Option A'}, |
| * {id: '2', name: 'Option B'}, |
| * {id: '3', name: 'Option C'} |
| * ], |
| * selectedOption: {id: '3', name: 'Option C'} //This sets the default value of the select in the ui |
| * }; |
| * }]); |
| * </file> |
| *</example> |
| * |
| * |
| * ### Binding `select` to a non-string value via `ngModel` parsing / formatting |
| * |
| * <example name="select-with-non-string-options" module="nonStringSelect"> |
| * <file name="index.html"> |
| * <select ng-model="model.id" convert-to-number> |
| * <option value="0">Zero</option> |
| * <option value="1">One</option> |
| * <option value="2">Two</option> |
| * </select> |
| * {{ model }} |
| * </file> |
| * <file name="app.js"> |
| * angular.module('nonStringSelect', []) |
| * .run(function($rootScope) { |
| * $rootScope.model = { id: 2 }; |
| * }) |
| * .directive('convertToNumber', function() { |
| * return { |
| * require: 'ngModel', |
| * link: function(scope, element, attrs, ngModel) { |
| * ngModel.$parsers.push(function(val) { |
| * return parseInt(val, 10); |
| * }); |
| * ngModel.$formatters.push(function(val) { |
| * return '' + val; |
| * }); |
| * } |
| * }; |
| * }); |
| * </file> |
| * <file name="protractor.js" type="protractor"> |
| * it('should initialize to model', function() { |
| * var select = element(by.css('select')); |
| * expect(element(by.model('model.id')).$('option:checked').getText()).toEqual('Two'); |
| * }); |
| * </file> |
| * </example> |
| * |
| */ |
| var selectDirective = function() { |
| |
| return { |
| restrict: 'E', |
| require: ['select', '?ngModel'], |
| controller: SelectController, |
| link: function(scope, element, attr, ctrls) { |
| |
| // if ngModel is not defined, we don't need to do anything |
| var ngModelCtrl = ctrls[1]; |
| if (!ngModelCtrl) return; |
| |
| var selectCtrl = ctrls[0]; |
| |
| selectCtrl.ngModelCtrl = ngModelCtrl; |
| |
| // We delegate rendering to the `writeValue` method, which can be changed |
| // if the select can have multiple selected values or if the options are being |
| // generated by `ngOptions` |
| ngModelCtrl.$render = function() { |
| selectCtrl.writeValue(ngModelCtrl.$viewValue); |
| }; |
| |
| // When the selected item(s) changes we delegate getting the value of the select control |
| // to the `readValue` method, which can be changed if the select can have multiple |
| // selected values or if the options are being generated by `ngOptions` |
| element.on('change', function() { |
| scope.$apply(function() { |
| ngModelCtrl.$setViewValue(selectCtrl.readValue()); |
| }); |
| }); |
| |
| // If the select allows multiple values then we need to modify how we read and write |
| // values from and to the control; also what it means for the value to be empty and |
| // we have to add an extra watch since ngModel doesn't work well with arrays - it |
| // doesn't trigger rendering if only an item in the array changes. |
| if (attr.multiple) { |
| |
| // Read value now needs to check each option to see if it is selected |
| selectCtrl.readValue = function readMultipleValue() { |
| var array = []; |
| forEach(element.find('option'), function(option) { |
| if (option.selected) { |
| array.push(option.value); |
| } |
| }); |
| return array; |
| }; |
| |
| // Write value now needs to set the selected property of each matching option |
| selectCtrl.writeValue = function writeMultipleValue(value) { |
| var items = new HashMap(value); |
| forEach(element.find('option'), function(option) { |
| option.selected = isDefined(items.get(option.value)); |
| }); |
| }; |
| |
| // we have to do it on each watch since ngModel watches reference, but |
| // we need to work of an array, so we need to see if anything was inserted/removed |
| var lastView, lastViewRef = NaN; |
| scope.$watch(function selectMultipleWatch() { |
| if (lastViewRef === ngModelCtrl.$viewValue && !equals(lastView, ngModelCtrl.$viewValue)) { |
| lastView = shallowCopy(ngModelCtrl.$viewValue); |
| ngModelCtrl.$render(); |
| } |
| lastViewRef = ngModelCtrl.$viewValue; |
| }); |
| |
| // If we are a multiple select then value is now a collection |
| // so the meaning of $isEmpty changes |
| ngModelCtrl.$isEmpty = function(value) { |
| return !value || value.length === 0; |
| }; |
| |
| } |
| } |
| }; |
| }; |
| |
| |
| // The option directive is purely designed to communicate the existence (or lack of) |
| // of dynamically created (and destroyed) option elements to their containing select |
| // directive via its controller. |
| var optionDirective = ['$interpolate', function($interpolate) { |
| |
| function chromeHack(optionElement) { |
| // Workaround for https://code.google.com/p/chromium/issues/detail?id=381459 |
| // Adding an <option selected="selected"> element to a <select required="required"> should |
| // automatically select the new element |
| if (optionElement[0].hasAttribute('selected')) { |
| optionElement[0].selected = true; |
| } |
| } |
| |
| return { |
| restrict: 'E', |
| priority: 100, |
| compile: function(element, attr) { |
| |
| if (isDefined(attr.value)) { |
| // If the value attribute is defined, check if it contains an interpolation |
| var valueInterpolated = $interpolate(attr.value, true); |
| } else { |
| // If the value attribute is not defined then we fall back to the |
| // text content of the option element, which may be interpolated |
| var interpolateFn = $interpolate(element.text(), true); |
| if (!interpolateFn) { |
| attr.$set('value', element.text()); |
| } |
| } |
| |
| return function(scope, element, attr) { |
| |
| // This is an optimization over using ^^ since we don't want to have to search |
| // all the way to the root of the DOM for every single option element |
| var selectCtrlName = '$selectController', |
| parent = element.parent(), |
| selectCtrl = parent.data(selectCtrlName) || |
| parent.parent().data(selectCtrlName); // in case we are in optgroup |
| |
| function addOption(optionValue) { |
| selectCtrl.addOption(optionValue, element); |
| selectCtrl.ngModelCtrl.$render(); |
| chromeHack(element); |
| } |
| |
| // Only update trigger option updates if this is an option within a `select` |
| // that also has `ngModel` attached |
| if (selectCtrl && selectCtrl.ngModelCtrl) { |
| |
| if (valueInterpolated) { |
| // The value attribute is interpolated |
| var oldVal; |
| attr.$observe('value', function valueAttributeObserveAction(newVal) { |
| if (isDefined(oldVal)) { |
| selectCtrl.removeOption(oldVal); |
| } |
| oldVal = newVal; |
| addOption(newVal); |
| }); |
| } else if (interpolateFn) { |
| // The text content is interpolated |
| scope.$watch(interpolateFn, function interpolateWatchAction(newVal, oldVal) { |
| attr.$set('value', newVal); |
| if (oldVal !== newVal) { |
| selectCtrl.removeOption(oldVal); |
| } |
| addOption(newVal); |
| }); |
| } else { |
| // The value attribute is static |
| addOption(attr.value); |
| } |
| |
| element.on('$destroy', function() { |
| selectCtrl.removeOption(attr.value); |
| selectCtrl.ngModelCtrl.$render(); |
| }); |
| } |
| }; |
| } |
| }; |
| }]; |
| |
| var styleDirective = valueFn({ |
| restrict: 'E', |
| terminal: false |
| }); |
| |
| var requiredDirective = function() { |
| return { |
| restrict: 'A', |
| require: '?ngModel', |
| link: function(scope, elm, attr, ctrl) { |
| if (!ctrl) return; |
| attr.required = true; // force truthy in case we are on non input element |
| |
| ctrl.$validators.required = function(modelValue, viewValue) { |
| return !attr.required || !ctrl.$isEmpty(viewValue); |
| }; |
| |
| attr.$observe('required', function() { |
| ctrl.$validate(); |
| }); |
| } |
| }; |
| }; |
| |
| |
| var patternDirective = function() { |
| return { |
| restrict: 'A', |
| require: '?ngModel', |
| link: function(scope, elm, attr, ctrl) { |
| if (!ctrl) return; |
| |
| var regexp, patternExp = attr.ngPattern || attr.pattern; |
| attr.$observe('pattern', function(regex) { |
| if (isString(regex) && regex.length > 0) { |
| regex = new RegExp('^' + regex + '$'); |
| } |
| |
| if (regex && !regex.test) { |
| throw minErr('ngPattern')('noregexp', |
| 'Expected {0} to be a RegExp but was {1}. Element: {2}', patternExp, |
| regex, startingTag(elm)); |
| } |
| |
| regexp = regex || undefined; |
| ctrl.$validate(); |
| }); |
| |
| ctrl.$validators.pattern = function(modelValue, viewValue) { |
| // HTML5 pattern constraint validates the input value, so we validate the viewValue |
| return ctrl.$isEmpty(viewValue) || isUndefined(regexp) || regexp.test(viewValue); |
| }; |
| } |
| }; |
| }; |
| |
| |
| var maxlengthDirective = function() { |
| return { |
| restrict: 'A', |
| require: '?ngModel', |
| link: function(scope, elm, attr, ctrl) { |
| if (!ctrl) return; |
| |
| var maxlength = -1; |
| attr.$observe('maxlength', function(value) { |
| var intVal = toInt(value); |
| maxlength = isNaN(intVal) ? -1 : intVal; |
| ctrl.$validate(); |
| }); |
| ctrl.$validators.maxlength = function(modelValue, viewValue) { |
| return (maxlength < 0) || ctrl.$isEmpty(viewValue) || (viewValue.length <= maxlength); |
| }; |
| } |
| }; |
| }; |
| |
| var minlengthDirective = function() { |
| return { |
| restrict: 'A', |
| require: '?ngModel', |
| link: function(scope, elm, attr, ctrl) { |
| if (!ctrl) return; |
| |
| var minlength = 0; |
| attr.$observe('minlength', function(value) { |
| minlength = toInt(value) || 0; |
| ctrl.$validate(); |
| }); |
| ctrl.$validators.minlength = function(modelValue, viewValue) { |
| return ctrl.$isEmpty(viewValue) || viewValue.length >= minlength; |
| }; |
| } |
| }; |
| }; |
| |
| if (window.angular.bootstrap) { |
| //AngularJS is already loaded, so we can return here... |
| console.log('WARNING: Tried to load angular more than once.'); |
| return; |
| } |
| |
| //try to bind to jquery now so that one can write jqLite(document).ready() |
| //but we will rebind on bootstrap again. |
| bindJQuery(); |
| |
| publishExternalAPI(angular); |
| |
| angular.module("ngLocale", [], ["$provide", function($provide) { |
| var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"}; |
| function getDecimals(n) { |
| n = n + ''; |
| var i = n.indexOf('.'); |
| return (i == -1) ? 0 : n.length - i - 1; |
| } |
| |
| function getVF(n, opt_precision) { |
| var v = opt_precision; |
| |
| if (undefined === v) { |
| v = Math.min(getDecimals(n), 3); |
| } |
| |
| var base = Math.pow(10, v); |
| var f = ((n * base) | 0) % base; |
| return {v: v, f: f}; |
| } |
| |
| $provide.value("$locale", { |
| "DATETIME_FORMATS": { |
| "AMPMS": [ |
| "AM", |
| "PM" |
| ], |
| "DAY": [ |
| "Sunday", |
| "Monday", |
| "Tuesday", |
| "Wednesday", |
| "Thursday", |
| "Friday", |
| "Saturday" |
| ], |
| "ERANAMES": [ |
| "Before Christ", |
| "Anno Domini" |
| ], |
| "ERAS": [ |
| "BC", |
| "AD" |
| ], |
| "FIRSTDAYOFWEEK": 6, |
| "MONTH": [ |
| "January", |
| "February", |
| "March", |
| "April", |
| "May", |
| "June", |
| "July", |
| "August", |
| "September", |
| "October", |
| "November", |
| "December" |
| ], |
| "SHORTDAY": [ |
| "Sun", |
| "Mon", |
| "Tue", |
| "Wed", |
| "Thu", |
| "Fri", |
| "Sat" |
| ], |
| "SHORTMONTH": [ |
| "Jan", |
| "Feb", |
| "Mar", |
| "Apr", |
| "May", |
| "Jun", |
| "Jul", |
| "Aug", |
| "Sep", |
| "Oct", |
| "Nov", |
| "Dec" |
| ], |
| "WEEKENDRANGE": [ |
| 5, |
| 6 |
| ], |
| "fullDate": "EEEE, MMMM d, y", |
| "longDate": "MMMM d, y", |
| "medium": "MMM d, y h:mm:ss a", |
| "mediumDate": "MMM d, y", |
| "mediumTime": "h:mm:ss a", |
| "short": "M/d/yy h:mm a", |
| "shortDate": "M/d/yy", |
| "shortTime": "h:mm a" |
| }, |
| "NUMBER_FORMATS": { |
| "CURRENCY_SYM": "$", |
| "DECIMAL_SEP": ".", |
| "GROUP_SEP": ",", |
| "PATTERNS": [ |
| { |
| "gSize": 3, |
| "lgSize": 3, |
| "maxFrac": 3, |
| "minFrac": 0, |
| "minInt": 1, |
| "negPre": "-", |
| "negSuf": "", |
| "posPre": "", |
| "posSuf": "" |
| }, |
| { |
| "gSize": 3, |
| "lgSize": 3, |
| "maxFrac": 2, |
| "minFrac": 2, |
| "minInt": 1, |
| "negPre": "-\u00a4", |
| "negSuf": "", |
| "posPre": "\u00a4", |
| "posSuf": "" |
| } |
| ] |
| }, |
| "id": "en-us", |
| "pluralCat": function(n, opt_precision) { var i = n | 0; var vf = getVF(n, opt_precision); if (i == 1 && vf.v == 0) { return PLURAL_CATEGORY.ONE; } return PLURAL_CATEGORY.OTHER;} |
| }); |
| }]); |
| |
| jqLite(document).ready(function() { |
| angularInit(document, bootstrap); |
| }); |
| |
| })(window, document); |
| |
| !window.angular.$$csp().noInlineStyle && window.angular.element(document.head).prepend('<style type="text/css">@charset "UTF-8";[ng\\:cloak],[ng-cloak],[data-ng-cloak],[x-ng-cloak],.ng-cloak,.x-ng-cloak,.ng-hide:not(.ng-hide-animate){display:none !important;}ng\\:form{display:block;}.ng-animate-shim{visibility:hidden;}.ng-anchor{position:absolute;}</style>'); |
| /** |
| * State-based routing for AngularJS |
| * @version v0.2.15 |
| * @link http://angular-ui.github.com/ |
| * @license MIT License, http://www.opensource.org/licenses/MIT |
| */ |
| |
| /* commonjs package manager support (eg componentjs) */ |
| if (typeof module !== "undefined" && typeof exports !== "undefined" && module.exports === exports){ |
| module.exports = 'ui.router'; |
| } |
| |
| (function (window, angular, undefined) { |
| /*jshint globalstrict:true*/ |
| /*global angular:false*/ |
| 'use strict'; |
| |
| var isDefined = angular.isDefined, |
| isFunction = angular.isFunction, |
| isString = angular.isString, |
| isObject = angular.isObject, |
| isArray = angular.isArray, |
| forEach = angular.forEach, |
| extend = angular.extend, |
| copy = angular.copy; |
| |
| function inherit(parent, extra) { |
| return extend(new (extend(function() {}, { prototype: parent }))(), extra); |
| } |
| |
| function merge(dst) { |
| forEach(arguments, function(obj) { |
| if (obj !== dst) { |
| forEach(obj, function(value, key) { |
| if (!dst.hasOwnProperty(key)) dst[key] = value; |
| }); |
| } |
| }); |
| return dst; |
| } |
| |
| /** |
| * Finds the common ancestor path between two states. |
| * |
| * @param {Object} first The first state. |
| * @param {Object} second The second state. |
| * @return {Array} Returns an array of state names in descending order, not including the root. |
| */ |
| function ancestors(first, second) { |
| var path = []; |
| |
| for (var n in first.path) { |
| if (first.path[n] !== second.path[n]) break; |
| path.push(first.path[n]); |
| } |
| return path; |
| } |
| |
| /** |
| * IE8-safe wrapper for `Object.keys()`. |
| * |
| * @param {Object} object A JavaScript object. |
| * @return {Array} Returns the keys of the object as an array. |
| */ |
| function objectKeys(object) { |
| if (Object.keys) { |
| return Object.keys(object); |
| } |
| var result = []; |
| |
| forEach(object, function(val, key) { |
| result.push(key); |
| }); |
| return result; |
| } |
| |
| /** |
| * IE8-safe wrapper for `Array.prototype.indexOf()`. |
| * |
| * @param {Array} array A JavaScript array. |
| * @param {*} value A value to search the array for. |
| * @return {Number} Returns the array index value of `value`, or `-1` if not present. |
| */ |
| function indexOf(array, value) { |
| if (Array.prototype.indexOf) { |
| return array.indexOf(value, Number(arguments[2]) || 0); |
| } |
| var len = array.length >>> 0, from = Number(arguments[2]) || 0; |
| from = (from < 0) ? Math.ceil(from) : Math.floor(from); |
| |
| if (from < 0) from += len; |
| |
| for (; from < len; from++) { |
| if (from in array && array[from] === value) return from; |
| } |
| return -1; |
| } |
| |
| /** |
| * Merges a set of parameters with all parameters inherited between the common parents of the |
| * current state and a given destination state. |
| * |
| * @param {Object} currentParams The value of the current state parameters ($stateParams). |
| * @param {Object} newParams The set of parameters which will be composited with inherited params. |
| * @param {Object} $current Internal definition of object representing the current state. |
| * @param {Object} $to Internal definition of object representing state to transition to. |
| */ |
| function inheritParams(currentParams, newParams, $current, $to) { |
| var parents = ancestors($current, $to), parentParams, inherited = {}, inheritList = []; |
| |
| for (var i in parents) { |
| if (!parents[i].params) continue; |
| parentParams = objectKeys(parents[i].params); |
| if (!parentParams.length) continue; |
| |
| for (var j in parentParams) { |
| if (indexOf(inheritList, parentParams[j]) >= 0) continue; |
| inheritList.push(parentParams[j]); |
| inherited[parentParams[j]] = currentParams[parentParams[j]]; |
| } |
| } |
| return extend({}, inherited, newParams); |
| } |
| |
| /** |
| * Performs a non-strict comparison of the subset of two objects, defined by a list of keys. |
| * |
| * @param {Object} a The first object. |
| * @param {Object} b The second object. |
| * @param {Array} keys The list of keys within each object to compare. If the list is empty or not specified, |
| * it defaults to the list of keys in `a`. |
| * @return {Boolean} Returns `true` if the keys match, otherwise `false`. |
| */ |
| function equalForKeys(a, b, keys) { |
| if (!keys) { |
| keys = []; |
| for (var n in a) keys.push(n); // Used instead of Object.keys() for IE8 compatibility |
| } |
| |
| for (var i=0; i<keys.length; i++) { |
| var k = keys[i]; |
| if (a[k] != b[k]) return false; // Not '===', values aren't necessarily normalized |
| } |
| return true; |
| } |
| |
| /** |
| * Returns the subset of an object, based on a list of keys. |
| * |
| * @param {Array} keys |
| * @param {Object} values |
| * @return {Boolean} Returns a subset of `values`. |
| */ |
| function filterByKeys(keys, values) { |
| var filtered = {}; |
| |
| forEach(keys, function (name) { |
| filtered[name] = values[name]; |
| }); |
| return filtered; |
| } |
| |
| // like _.indexBy |
| // when you know that your index values will be unique, or you want last-one-in to win |
| function indexBy(array, propName) { |
| var result = {}; |
| forEach(array, function(item) { |
| result[item[propName]] = item; |
| }); |
| return result; |
| } |
| |
| // extracted from underscore.js |
| // Return a copy of the object only containing the whitelisted properties. |
| function pick(obj) { |
| var copy = {}; |
| var keys = Array.prototype.concat.apply(Array.prototype, Array.prototype.slice.call(arguments, 1)); |
| forEach(keys, function(key) { |
| if (key in obj) copy[key] = obj[key]; |
| }); |
| return copy; |
| } |
| |
| // extracted from underscore.js |
| // Return a copy of the object omitting the blacklisted properties. |
| function omit(obj) { |
| var copy = {}; |
| var keys = Array.prototype.concat.apply(Array.prototype, Array.prototype.slice.call(arguments, 1)); |
| for (var key in obj) { |
| if (indexOf(keys, key) == -1) copy[key] = obj[key]; |
| } |
| return copy; |
| } |
| |
| function pluck(collection, key) { |
| var result = isArray(collection) ? [] : {}; |
| |
| forEach(collection, function(val, i) { |
| result[i] = isFunction(key) ? key(val) : val[key]; |
| }); |
| return result; |
| } |
| |
| function filter(collection, callback) { |
| var array = isArray(collection); |
| var result = array ? [] : {}; |
| forEach(collection, function(val, i) { |
| if (callback(val, i)) { |
| result[array ? result.length : i] = val; |
| } |
| }); |
| return result; |
| } |
| |
| function map(collection, callback) { |
| var result = isArray(collection) ? [] : {}; |
| |
| forEach(collection, function(val, i) { |
| result[i] = callback(val, i); |
| }); |
| return result; |
| } |
| |
| /** |
| * @ngdoc overview |
| * @name ui.router.util |
| * |
| * @description |
| * # ui.router.util sub-module |
| * |
| * This module is a dependency of other sub-modules. Do not include this module as a dependency |
| * in your angular app (use {@link ui.router} module instead). |
| * |
| */ |
| angular.module('ui.router.util', ['ng']); |
| |
| /** |
| * @ngdoc overview |
| * @name ui.router.router |
| * |
| * @requires ui.router.util |
| * |
| * @description |
| * # ui.router.router sub-module |
| * |
| * This module is a dependency of other sub-modules. Do not include this module as a dependency |
| * in your angular app (use {@link ui.router} module instead). |
| */ |
| angular.module('ui.router.router', ['ui.router.util']); |
| |
| /** |
| * @ngdoc overview |
| * @name ui.router.state |
| * |
| * @requires ui.router.router |
| * @requires ui.router.util |
| * |
| * @description |
| * # ui.router.state sub-module |
| * |
| * This module is a dependency of the main ui.router module. Do not include this module as a dependency |
| * in your angular app (use {@link ui.router} module instead). |
| * |
| */ |
| angular.module('ui.router.state', ['ui.router.router', 'ui.router.util']); |
| |
| /** |
| * @ngdoc overview |
| * @name ui.router |
| * |
| * @requires ui.router.state |
| * |
| * @description |
| * # ui.router |
| * |
| * ## The main module for ui.router |
| * There are several sub-modules included with the ui.router module, however only this module is needed |
| * as a dependency within your angular app. The other modules are for organization purposes. |
| * |
| * The modules are: |
| * * ui.router - the main "umbrella" module |
| * * ui.router.router - |
| * |
| * *You'll need to include **only** this module as the dependency within your angular app.* |
| * |
| * <pre> |
| * <!doctype html> |
| * <html ng-app="myApp"> |
| * <head> |
| * <script src="js/angular.js"></script> |
| * <!-- Include the ui-router script --> |
| * <script src="js/angular-ui-router.min.js"></script> |
| * <script> |
| * // ...and add 'ui.router' as a dependency |
| * var myApp = angular.module('myApp', ['ui.router']); |
| * </script> |
| * </head> |
| * <body> |
| * </body> |
| * </html> |
| * </pre> |
| */ |
| angular.module('ui.router', ['ui.router.state']); |
| |
| angular.module('ui.router.compat', ['ui.router']); |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.util.$resolve |
| * |
| * @requires $q |
| * @requires $injector |
| * |
| * @description |
| * Manages resolution of (acyclic) graphs of promises. |
| */ |
| $Resolve.$inject = ['$q', '$injector']; |
| function $Resolve( $q, $injector) { |
| |
| var VISIT_IN_PROGRESS = 1, |
| VISIT_DONE = 2, |
| NOTHING = {}, |
| NO_DEPENDENCIES = [], |
| NO_LOCALS = NOTHING, |
| NO_PARENT = extend($q.when(NOTHING), { $$promises: NOTHING, $$values: NOTHING }); |
| |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$resolve#study |
| * @methodOf ui.router.util.$resolve |
| * |
| * @description |
| * Studies a set of invocables that are likely to be used multiple times. |
| * <pre> |
| * $resolve.study(invocables)(locals, parent, self) |
| * </pre> |
| * is equivalent to |
| * <pre> |
| * $resolve.resolve(invocables, locals, parent, self) |
| * </pre> |
| * but the former is more efficient (in fact `resolve` just calls `study` |
| * internally). |
| * |
| * @param {object} invocables Invocable objects |
| * @return {function} a function to pass in locals, parent and self |
| */ |
| this.study = function (invocables) { |
| if (!isObject(invocables)) throw new Error("'invocables' must be an object"); |
| var invocableKeys = objectKeys(invocables || {}); |
| |
| // Perform a topological sort of invocables to build an ordered plan |
| var plan = [], cycle = [], visited = {}; |
| function visit(value, key) { |
| if (visited[key] === VISIT_DONE) return; |
| |
| cycle.push(key); |
| if (visited[key] === VISIT_IN_PROGRESS) { |
| cycle.splice(0, indexOf(cycle, key)); |
| throw new Error("Cyclic dependency: " + cycle.join(" -> ")); |
| } |
| visited[key] = VISIT_IN_PROGRESS; |
| |
| if (isString(value)) { |
| plan.push(key, [ function() { return $injector.get(value); }], NO_DEPENDENCIES); |
| } else { |
| var params = $injector.annotate(value); |
| forEach(params, function (param) { |
| if (param !== key && invocables.hasOwnProperty(param)) visit(invocables[param], param); |
| }); |
| plan.push(key, value, params); |
| } |
| |
| cycle.pop(); |
| visited[key] = VISIT_DONE; |
| } |
| forEach(invocables, visit); |
| invocables = cycle = visited = null; // plan is all that's required |
| |
| function isResolve(value) { |
| return isObject(value) && value.then && value.$$promises; |
| } |
| |
| return function (locals, parent, self) { |
| if (isResolve(locals) && self === undefined) { |
| self = parent; parent = locals; locals = null; |
| } |
| if (!locals) locals = NO_LOCALS; |
| else if (!isObject(locals)) { |
| throw new Error("'locals' must be an object"); |
| } |
| if (!parent) parent = NO_PARENT; |
| else if (!isResolve(parent)) { |
| throw new Error("'parent' must be a promise returned by $resolve.resolve()"); |
| } |
| |
| // To complete the overall resolution, we have to wait for the parent |
| // promise and for the promise for each invokable in our plan. |
| var resolution = $q.defer(), |
| result = resolution.promise, |
| promises = result.$$promises = {}, |
| values = extend({}, locals), |
| wait = 1 + plan.length/3, |
| merged = false; |
| |
| function done() { |
| // Merge parent values we haven't got yet and publish our own $$values |
| if (!--wait) { |
| if (!merged) merge(values, parent.$$values); |
| result.$$values = values; |
| result.$$promises = result.$$promises || true; // keep for isResolve() |
| delete result.$$inheritedValues; |
| resolution.resolve(values); |
| } |
| } |
| |
| function fail(reason) { |
| result.$$failure = reason; |
| resolution.reject(reason); |
| } |
| |
| // Short-circuit if parent has already failed |
| if (isDefined(parent.$$failure)) { |
| fail(parent.$$failure); |
| return result; |
| } |
| |
| if (parent.$$inheritedValues) { |
| merge(values, omit(parent.$$inheritedValues, invocableKeys)); |
| } |
| |
| // Merge parent values if the parent has already resolved, or merge |
| // parent promises and wait if the parent resolve is still in progress. |
| extend(promises, parent.$$promises); |
| if (parent.$$values) { |
| merged = merge(values, omit(parent.$$values, invocableKeys)); |
| result.$$inheritedValues = omit(parent.$$values, invocableKeys); |
| done(); |
| } else { |
| if (parent.$$inheritedValues) { |
| result.$$inheritedValues = omit(parent.$$inheritedValues, invocableKeys); |
| } |
| parent.then(done, fail); |
| } |
| |
| // Process each invocable in the plan, but ignore any where a local of the same name exists. |
| for (var i=0, ii=plan.length; i<ii; i+=3) { |
| if (locals.hasOwnProperty(plan[i])) done(); |
| else invoke(plan[i], plan[i+1], plan[i+2]); |
| } |
| |
| function invoke(key, invocable, params) { |
| // Create a deferred for this invocation. Failures will propagate to the resolution as well. |
| var invocation = $q.defer(), waitParams = 0; |
| function onfailure(reason) { |
| invocation.reject(reason); |
| fail(reason); |
| } |
| // Wait for any parameter that we have a promise for (either from parent or from this |
| // resolve; in that case study() will have made sure it's ordered before us in the plan). |
| forEach(params, function (dep) { |
| if (promises.hasOwnProperty(dep) && !locals.hasOwnProperty(dep)) { |
| waitParams++; |
| promises[dep].then(function (result) { |
| values[dep] = result; |
| if (!(--waitParams)) proceed(); |
| }, onfailure); |
| } |
| }); |
| if (!waitParams) proceed(); |
| function proceed() { |
| if (isDefined(result.$$failure)) return; |
| try { |
| invocation.resolve($injector.invoke(invocable, self, values)); |
| invocation.promise.then(function (result) { |
| values[key] = result; |
| done(); |
| }, onfailure); |
| } catch (e) { |
| onfailure(e); |
| } |
| } |
| // Publish promise synchronously; invocations further down in the plan may depend on it. |
| promises[key] = invocation.promise; |
| } |
| |
| return result; |
| }; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$resolve#resolve |
| * @methodOf ui.router.util.$resolve |
| * |
| * @description |
| * Resolves a set of invocables. An invocable is a function to be invoked via |
| * `$injector.invoke()`, and can have an arbitrary number of dependencies. |
| * An invocable can either return a value directly, |
| * or a `$q` promise. If a promise is returned it will be resolved and the |
| * resulting value will be used instead. Dependencies of invocables are resolved |
| * (in this order of precedence) |
| * |
| * - from the specified `locals` |
| * - from another invocable that is part of this `$resolve` call |
| * - from an invocable that is inherited from a `parent` call to `$resolve` |
| * (or recursively |
| * - from any ancestor `$resolve` of that parent). |
| * |
| * The return value of `$resolve` is a promise for an object that contains |
| * (in this order of precedence) |
| * |
| * - any `locals` (if specified) |
| * - the resolved return values of all injectables |
| * - any values inherited from a `parent` call to `$resolve` (if specified) |
| * |
| * The promise will resolve after the `parent` promise (if any) and all promises |
| * returned by injectables have been resolved. If any invocable |
| * (or `$injector.invoke`) throws an exception, or if a promise returned by an |
| * invocable is rejected, the `$resolve` promise is immediately rejected with the |
| * same error. A rejection of a `parent` promise (if specified) will likewise be |
| * propagated immediately. Once the `$resolve` promise has been rejected, no |
| * further invocables will be called. |
| * |
| * Cyclic dependencies between invocables are not permitted and will caues `$resolve` |
| * to throw an error. As a special case, an injectable can depend on a parameter |
| * with the same name as the injectable, which will be fulfilled from the `parent` |
| * injectable of the same name. This allows inherited values to be decorated. |
| * Note that in this case any other injectable in the same `$resolve` with the same |
| * dependency would see the decorated value, not the inherited value. |
| * |
| * Note that missing dependencies -- unlike cyclic dependencies -- will cause an |
| * (asynchronous) rejection of the `$resolve` promise rather than a (synchronous) |
| * exception. |
| * |
| * Invocables are invoked eagerly as soon as all dependencies are available. |
| * This is true even for dependencies inherited from a `parent` call to `$resolve`. |
| * |
| * As a special case, an invocable can be a string, in which case it is taken to |
| * be a service name to be passed to `$injector.get()`. This is supported primarily |
| * for backwards-compatibility with the `resolve` property of `$routeProvider` |
| * routes. |
| * |
| * @param {object} invocables functions to invoke or |
| * `$injector` services to fetch. |
| * @param {object} locals values to make available to the injectables |
| * @param {object} parent a promise returned by another call to `$resolve`. |
| * @param {object} self the `this` for the invoked methods |
| * @return {object} Promise for an object that contains the resolved return value |
| * of all invocables, as well as any inherited and local values. |
| */ |
| this.resolve = function (invocables, locals, parent, self) { |
| return this.study(invocables)(locals, parent, self); |
| }; |
| } |
| |
| angular.module('ui.router.util').service('$resolve', $Resolve); |
| |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.util.$templateFactory |
| * |
| * @requires $http |
| * @requires $templateCache |
| * @requires $injector |
| * |
| * @description |
| * Service. Manages loading of templates. |
| */ |
| $TemplateFactory.$inject = ['$http', '$templateCache', '$injector']; |
| function $TemplateFactory( $http, $templateCache, $injector) { |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$templateFactory#fromConfig |
| * @methodOf ui.router.util.$templateFactory |
| * |
| * @description |
| * Creates a template from a configuration object. |
| * |
| * @param {object} config Configuration object for which to load a template. |
| * The following properties are search in the specified order, and the first one |
| * that is defined is used to create the template: |
| * |
| * @param {string|object} config.template html string template or function to |
| * load via {@link ui.router.util.$templateFactory#fromString fromString}. |
| * @param {string|object} config.templateUrl url to load or a function returning |
| * the url to load via {@link ui.router.util.$templateFactory#fromUrl fromUrl}. |
| * @param {Function} config.templateProvider function to invoke via |
| * {@link ui.router.util.$templateFactory#fromProvider fromProvider}. |
| * @param {object} params Parameters to pass to the template function. |
| * @param {object} locals Locals to pass to `invoke` if the template is loaded |
| * via a `templateProvider`. Defaults to `{ params: params }`. |
| * |
| * @return {string|object} The template html as a string, or a promise for |
| * that string,or `null` if no template is configured. |
| */ |
| this.fromConfig = function (config, params, locals) { |
| return ( |
| isDefined(config.template) ? this.fromString(config.template, params) : |
| isDefined(config.templateUrl) ? this.fromUrl(config.templateUrl, params) : |
| isDefined(config.templateProvider) ? this.fromProvider(config.templateProvider, params, locals) : |
| null |
| ); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$templateFactory#fromString |
| * @methodOf ui.router.util.$templateFactory |
| * |
| * @description |
| * Creates a template from a string or a function returning a string. |
| * |
| * @param {string|object} template html template as a string or function that |
| * returns an html template as a string. |
| * @param {object} params Parameters to pass to the template function. |
| * |
| * @return {string|object} The template html as a string, or a promise for that |
| * string. |
| */ |
| this.fromString = function (template, params) { |
| return isFunction(template) ? template(params) : template; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$templateFactory#fromUrl |
| * @methodOf ui.router.util.$templateFactory |
| * |
| * @description |
| * Loads a template from the a URL via `$http` and `$templateCache`. |
| * |
| * @param {string|Function} url url of the template to load, or a function |
| * that returns a url. |
| * @param {Object} params Parameters to pass to the url function. |
| * @return {string|Promise.<string>} The template html as a string, or a promise |
| * for that string. |
| */ |
| this.fromUrl = function (url, params) { |
| if (isFunction(url)) url = url(params); |
| if (url == null) return null; |
| else return $http |
| .get(url, { cache: $templateCache, headers: { Accept: 'text/html' }}) |
| .then(function(response) { return response.data; }); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$templateFactory#fromProvider |
| * @methodOf ui.router.util.$templateFactory |
| * |
| * @description |
| * Creates a template by invoking an injectable provider function. |
| * |
| * @param {Function} provider Function to invoke via `$injector.invoke` |
| * @param {Object} params Parameters for the template. |
| * @param {Object} locals Locals to pass to `invoke`. Defaults to |
| * `{ params: params }`. |
| * @return {string|Promise.<string>} The template html as a string, or a promise |
| * for that string. |
| */ |
| this.fromProvider = function (provider, params, locals) { |
| return $injector.invoke(provider, null, locals || { params: params }); |
| }; |
| } |
| |
| angular.module('ui.router.util').service('$templateFactory', $TemplateFactory); |
| |
| var $$UMFP; // reference to $UrlMatcherFactoryProvider |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.util.type:UrlMatcher |
| * |
| * @description |
| * Matches URLs against patterns and extracts named parameters from the path or the search |
| * part of the URL. A URL pattern consists of a path pattern, optionally followed by '?' and a list |
| * of search parameters. Multiple search parameter names are separated by '&'. Search parameters |
| * do not influence whether or not a URL is matched, but their values are passed through into |
| * the matched parameters returned by {@link ui.router.util.type:UrlMatcher#methods_exec exec}. |
| * |
| * Path parameter placeholders can be specified using simple colon/catch-all syntax or curly brace |
| * syntax, which optionally allows a regular expression for the parameter to be specified: |
| * |
| * * `':'` name - colon placeholder |
| * * `'*'` name - catch-all placeholder |
| * * `'{' name '}'` - curly placeholder |
| * * `'{' name ':' regexp|type '}'` - curly placeholder with regexp or type name. Should the |
| * regexp itself contain curly braces, they must be in matched pairs or escaped with a backslash. |
| * |
| * Parameter names may contain only word characters (latin letters, digits, and underscore) and |
| * must be unique within the pattern (across both path and search parameters). For colon |
| * placeholders or curly placeholders without an explicit regexp, a path parameter matches any |
| * number of characters other than '/'. For catch-all placeholders the path parameter matches |
| * any number of characters. |
| * |
| * Examples: |
| * |
| * * `'/hello/'` - Matches only if the path is exactly '/hello/'. There is no special treatment for |
| * trailing slashes, and patterns have to match the entire path, not just a prefix. |
| * * `'/user/:id'` - Matches '/user/bob' or '/user/1234!!!' or even '/user/' but not '/user' or |
| * '/user/bob/details'. The second path segment will be captured as the parameter 'id'. |
| * * `'/user/{id}'` - Same as the previous example, but using curly brace syntax. |
| * * `'/user/{id:[^/]*}'` - Same as the previous example. |
| * * `'/user/{id:[0-9a-fA-F]{1,8}}'` - Similar to the previous example, but only matches if the id |
| * parameter consists of 1 to 8 hex digits. |
| * * `'/files/{path:.*}'` - Matches any URL starting with '/files/' and captures the rest of the |
| * path into the parameter 'path'. |
| * * `'/files/*path'` - ditto. |
| * * `'/calendar/{start:date}'` - Matches "/calendar/2014-11-12" (because the pattern defined |
| * in the built-in `date` Type matches `2014-11-12`) and provides a Date object in $stateParams.start |
| * |
| * @param {string} pattern The pattern to compile into a matcher. |
| * @param {Object} config A configuration object hash: |
| * @param {Object=} parentMatcher Used to concatenate the pattern/config onto |
| * an existing UrlMatcher |
| * |
| * * `caseInsensitive` - `true` if URL matching should be case insensitive, otherwise `false`, the default value (for backward compatibility) is `false`. |
| * * `strict` - `false` if matching against a URL with a trailing slash should be treated as equivalent to a URL without a trailing slash, the default value is `true`. |
| * |
| * @property {string} prefix A static prefix of this pattern. The matcher guarantees that any |
| * URL matching this matcher (i.e. any string for which {@link ui.router.util.type:UrlMatcher#methods_exec exec()} returns |
| * non-null) will start with this prefix. |
| * |
| * @property {string} source The pattern that was passed into the constructor |
| * |
| * @property {string} sourcePath The path portion of the source property |
| * |
| * @property {string} sourceSearch The search portion of the source property |
| * |
| * @property {string} regex The constructed regex that will be used to match against the url when |
| * it is time to determine which url will match. |
| * |
| * @returns {Object} New `UrlMatcher` object |
| */ |
| function UrlMatcher(pattern, config, parentMatcher) { |
| config = extend({ params: {} }, isObject(config) ? config : {}); |
| |
| // Find all placeholders and create a compiled pattern, using either classic or curly syntax: |
| // '*' name |
| // ':' name |
| // '{' name '}' |
| // '{' name ':' regexp '}' |
| // The regular expression is somewhat complicated due to the need to allow curly braces |
| // inside the regular expression. The placeholder regexp breaks down as follows: |
| // ([:*])([\w\[\]]+) - classic placeholder ($1 / $2) (search version has - for snake-case) |
| // \{([\w\[\]]+)(?:\:( ... ))?\} - curly brace placeholder ($3) with optional regexp/type ... ($4) (search version has - for snake-case |
| // (?: ... | ... | ... )+ - the regexp consists of any number of atoms, an atom being either |
| // [^{}\\]+ - anything other than curly braces or backslash |
| // \\. - a backslash escape |
| // \{(?:[^{}\\]+|\\.)*\} - a matched set of curly braces containing other atoms |
| var placeholder = /([:*])([\w\[\]]+)|\{([\w\[\]]+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g, |
| searchPlaceholder = /([:]?)([\w\[\]-]+)|\{([\w\[\]-]+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g, |
| compiled = '^', last = 0, m, |
| segments = this.segments = [], |
| parentParams = parentMatcher ? parentMatcher.params : {}, |
| params = this.params = parentMatcher ? parentMatcher.params.$$new() : new $$UMFP.ParamSet(), |
| paramNames = []; |
| |
| function addParameter(id, type, config, location) { |
| paramNames.push(id); |
| if (parentParams[id]) return parentParams[id]; |
| if (!/^\w+(-+\w+)*(?:\[\])?$/.test(id)) throw new Error("Invalid parameter name '" + id + "' in pattern '" + pattern + "'"); |
| if (params[id]) throw new Error("Duplicate parameter name '" + id + "' in pattern '" + pattern + "'"); |
| params[id] = new $$UMFP.Param(id, type, config, location); |
| return params[id]; |
| } |
| |
| function quoteRegExp(string, pattern, squash, optional) { |
| var surroundPattern = ['',''], result = string.replace(/[\\\[\]\^$*+?.()|{}]/g, "\\$&"); |
| if (!pattern) return result; |
| switch(squash) { |
| case false: surroundPattern = ['(', ')' + (optional ? "?" : "")]; break; |
| case true: surroundPattern = ['?(', ')?']; break; |
| default: surroundPattern = ['(' + squash + "|", ')?']; break; |
| } |
| return result + surroundPattern[0] + pattern + surroundPattern[1]; |
| } |
| |
| this.source = pattern; |
| |
| // Split into static segments separated by path parameter placeholders. |
| // The number of segments is always 1 more than the number of parameters. |
| function matchDetails(m, isSearch) { |
| var id, regexp, segment, type, cfg, arrayMode; |
| id = m[2] || m[3]; // IE[78] returns '' for unmatched groups instead of null |
| cfg = config.params[id]; |
| segment = pattern.substring(last, m.index); |
| regexp = isSearch ? m[4] : m[4] || (m[1] == '*' ? '.*' : null); |
| type = $$UMFP.type(regexp || "string") || inherit($$UMFP.type("string"), { pattern: new RegExp(regexp, config.caseInsensitive ? 'i' : undefined) }); |
| return { |
| id: id, regexp: regexp, segment: segment, type: type, cfg: cfg |
| }; |
| } |
| |
| var p, param, segment; |
| while ((m = placeholder.exec(pattern))) { |
| p = matchDetails(m, false); |
| if (p.segment.indexOf('?') >= 0) break; // we're into the search part |
| |
| param = addParameter(p.id, p.type, p.cfg, "path"); |
| compiled += quoteRegExp(p.segment, param.type.pattern.source, param.squash, param.isOptional); |
| segments.push(p.segment); |
| last = placeholder.lastIndex; |
| } |
| segment = pattern.substring(last); |
| |
| // Find any search parameter names and remove them from the last segment |
| var i = segment.indexOf('?'); |
| |
| if (i >= 0) { |
| var search = this.sourceSearch = segment.substring(i); |
| segment = segment.substring(0, i); |
| this.sourcePath = pattern.substring(0, last + i); |
| |
| if (search.length > 0) { |
| last = 0; |
| while ((m = searchPlaceholder.exec(search))) { |
| p = matchDetails(m, true); |
| param = addParameter(p.id, p.type, p.cfg, "search"); |
| last = placeholder.lastIndex; |
| // check if ?& |
| } |
| } |
| } else { |
| this.sourcePath = pattern; |
| this.sourceSearch = ''; |
| } |
| |
| compiled += quoteRegExp(segment) + (config.strict === false ? '\/?' : '') + '$'; |
| segments.push(segment); |
| |
| this.regexp = new RegExp(compiled, config.caseInsensitive ? 'i' : undefined); |
| this.prefix = segments[0]; |
| this.$$paramNames = paramNames; |
| } |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:UrlMatcher#concat |
| * @methodOf ui.router.util.type:UrlMatcher |
| * |
| * @description |
| * Returns a new matcher for a pattern constructed by appending the path part and adding the |
| * search parameters of the specified pattern to this pattern. The current pattern is not |
| * modified. This can be understood as creating a pattern for URLs that are relative to (or |
| * suffixes of) the current pattern. |
| * |
| * @example |
| * The following two matchers are equivalent: |
| * <pre> |
| * new UrlMatcher('/user/{id}?q').concat('/details?date'); |
| * new UrlMatcher('/user/{id}/details?q&date'); |
| * </pre> |
| * |
| * @param {string} pattern The pattern to append. |
| * @param {Object} config An object hash of the configuration for the matcher. |
| * @returns {UrlMatcher} A matcher for the concatenated pattern. |
| */ |
| UrlMatcher.prototype.concat = function (pattern, config) { |
| // Because order of search parameters is irrelevant, we can add our own search |
| // parameters to the end of the new pattern. Parse the new pattern by itself |
| // and then join the bits together, but it's much easier to do this on a string level. |
| var defaultConfig = { |
| caseInsensitive: $$UMFP.caseInsensitive(), |
| strict: $$UMFP.strictMode(), |
| squash: $$UMFP.defaultSquashPolicy() |
| }; |
| return new UrlMatcher(this.sourcePath + pattern + this.sourceSearch, extend(defaultConfig, config), this); |
| }; |
| |
| UrlMatcher.prototype.toString = function () { |
| return this.source; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:UrlMatcher#exec |
| * @methodOf ui.router.util.type:UrlMatcher |
| * |
| * @description |
| * Tests the specified path against this matcher, and returns an object containing the captured |
| * parameter values, or null if the path does not match. The returned object contains the values |
| * of any search parameters that are mentioned in the pattern, but their value may be null if |
| * they are not present in `searchParams`. This means that search parameters are always treated |
| * as optional. |
| * |
| * @example |
| * <pre> |
| * new UrlMatcher('/user/{id}?q&r').exec('/user/bob', { |
| * x: '1', q: 'hello' |
| * }); |
| * // returns { id: 'bob', q: 'hello', r: null } |
| * </pre> |
| * |
| * @param {string} path The URL path to match, e.g. `$location.path()`. |
| * @param {Object} searchParams URL search parameters, e.g. `$location.search()`. |
| * @returns {Object} The captured parameter values. |
| */ |
| UrlMatcher.prototype.exec = function (path, searchParams) { |
| var m = this.regexp.exec(path); |
| if (!m) return null; |
| searchParams = searchParams || {}; |
| |
| var paramNames = this.parameters(), nTotal = paramNames.length, |
| nPath = this.segments.length - 1, |
| values = {}, i, j, cfg, paramName; |
| |
| if (nPath !== m.length - 1) throw new Error("Unbalanced capture group in route '" + this.source + "'"); |
| |
| function decodePathArray(string) { |
| function reverseString(str) { return str.split("").reverse().join(""); } |
| function unquoteDashes(str) { return str.replace(/\\-/g, "-"); } |
| |
| var split = reverseString(string).split(/-(?!\\)/); |
| var allReversed = map(split, reverseString); |
| return map(allReversed, unquoteDashes).reverse(); |
| } |
| |
| for (i = 0; i < nPath; i++) { |
| paramName = paramNames[i]; |
| var param = this.params[paramName]; |
| var paramVal = m[i+1]; |
| // if the param value matches a pre-replace pair, replace the value before decoding. |
| for (j = 0; j < param.replace; j++) { |
| if (param.replace[j].from === paramVal) paramVal = param.replace[j].to; |
| } |
| if (paramVal && param.array === true) paramVal = decodePathArray(paramVal); |
| values[paramName] = param.value(paramVal); |
| } |
| for (/**/; i < nTotal; i++) { |
| paramName = paramNames[i]; |
| values[paramName] = this.params[paramName].value(searchParams[paramName]); |
| } |
| |
| return values; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:UrlMatcher#parameters |
| * @methodOf ui.router.util.type:UrlMatcher |
| * |
| * @description |
| * Returns the names of all path and search parameters of this pattern in an unspecified order. |
| * |
| * @returns {Array.<string>} An array of parameter names. Must be treated as read-only. If the |
| * pattern has no parameters, an empty array is returned. |
| */ |
| UrlMatcher.prototype.parameters = function (param) { |
| if (!isDefined(param)) return this.$$paramNames; |
| return this.params[param] || null; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:UrlMatcher#validate |
| * @methodOf ui.router.util.type:UrlMatcher |
| * |
| * @description |
| * Checks an object hash of parameters to validate their correctness according to the parameter |
| * types of this `UrlMatcher`. |
| * |
| * @param {Object} params The object hash of parameters to validate. |
| * @returns {boolean} Returns `true` if `params` validates, otherwise `false`. |
| */ |
| UrlMatcher.prototype.validates = function (params) { |
| return this.params.$$validates(params); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:UrlMatcher#format |
| * @methodOf ui.router.util.type:UrlMatcher |
| * |
| * @description |
| * Creates a URL that matches this pattern by substituting the specified values |
| * for the path and search parameters. Null values for path parameters are |
| * treated as empty strings. |
| * |
| * @example |
| * <pre> |
| * new UrlMatcher('/user/{id}?q').format({ id:'bob', q:'yes' }); |
| * // returns '/user/bob?q=yes' |
| * </pre> |
| * |
| * @param {Object} values the values to substitute for the parameters in this pattern. |
| * @returns {string} the formatted URL (path and optionally search part). |
| */ |
| UrlMatcher.prototype.format = function (values) { |
| values = values || {}; |
| var segments = this.segments, params = this.parameters(), paramset = this.params; |
| if (!this.validates(values)) return null; |
| |
| var i, search = false, nPath = segments.length - 1, nTotal = params.length, result = segments[0]; |
| |
| function encodeDashes(str) { // Replace dashes with encoded "\-" |
| return encodeURIComponent(str).replace(/-/g, function(c) { return '%5C%' + c.charCodeAt(0).toString(16).toUpperCase(); }); |
| } |
| |
| for (i = 0; i < nTotal; i++) { |
| var isPathParam = i < nPath; |
| var name = params[i], param = paramset[name], value = param.value(values[name]); |
| var isDefaultValue = param.isOptional && param.type.equals(param.value(), value); |
| var squash = isDefaultValue ? param.squash : false; |
| var encoded = param.type.encode(value); |
| |
| if (isPathParam) { |
| var nextSegment = segments[i + 1]; |
| if (squash === false) { |
| if (encoded != null) { |
| if (isArray(encoded)) { |
| result += map(encoded, encodeDashes).join("-"); |
| } else { |
| result += encodeURIComponent(encoded); |
| } |
| } |
| result += nextSegment; |
| } else if (squash === true) { |
| var capture = result.match(/\/$/) ? /\/?(.*)/ : /(.*)/; |
| result += nextSegment.match(capture)[1]; |
| } else if (isString(squash)) { |
| result += squash + nextSegment; |
| } |
| } else { |
| if (encoded == null || (isDefaultValue && squash !== false)) continue; |
| if (!isArray(encoded)) encoded = [ encoded ]; |
| encoded = map(encoded, encodeURIComponent).join('&' + name + '='); |
| result += (search ? '&' : '?') + (name + '=' + encoded); |
| search = true; |
| } |
| } |
| |
| return result; |
| }; |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.util.type:Type |
| * |
| * @description |
| * Implements an interface to define custom parameter types that can be decoded from and encoded to |
| * string parameters matched in a URL. Used by {@link ui.router.util.type:UrlMatcher `UrlMatcher`} |
| * objects when matching or formatting URLs, or comparing or validating parameter values. |
| * |
| * See {@link ui.router.util.$urlMatcherFactory#methods_type `$urlMatcherFactory#type()`} for more |
| * information on registering custom types. |
| * |
| * @param {Object} config A configuration object which contains the custom type definition. The object's |
| * properties will override the default methods and/or pattern in `Type`'s public interface. |
| * @example |
| * <pre> |
| * { |
| * decode: function(val) { return parseInt(val, 10); }, |
| * encode: function(val) { return val && val.toString(); }, |
| * equals: function(a, b) { return this.is(a) && a === b; }, |
| * is: function(val) { return angular.isNumber(val) isFinite(val) && val % 1 === 0; }, |
| * pattern: /\d+/ |
| * } |
| * </pre> |
| * |
| * @property {RegExp} pattern The regular expression pattern used to match values of this type when |
| * coming from a substring of a URL. |
| * |
| * @returns {Object} Returns a new `Type` object. |
| */ |
| function Type(config) { |
| extend(this, config); |
| } |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:Type#is |
| * @methodOf ui.router.util.type:Type |
| * |
| * @description |
| * Detects whether a value is of a particular type. Accepts a native (decoded) value |
| * and determines whether it matches the current `Type` object. |
| * |
| * @param {*} val The value to check. |
| * @param {string} key Optional. If the type check is happening in the context of a specific |
| * {@link ui.router.util.type:UrlMatcher `UrlMatcher`} object, this is the name of the |
| * parameter in which `val` is stored. Can be used for meta-programming of `Type` objects. |
| * @returns {Boolean} Returns `true` if the value matches the type, otherwise `false`. |
| */ |
| Type.prototype.is = function(val, key) { |
| return true; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:Type#encode |
| * @methodOf ui.router.util.type:Type |
| * |
| * @description |
| * Encodes a custom/native type value to a string that can be embedded in a URL. Note that the |
| * return value does *not* need to be URL-safe (i.e. passed through `encodeURIComponent()`), it |
| * only needs to be a representation of `val` that has been coerced to a string. |
| * |
| * @param {*} val The value to encode. |
| * @param {string} key The name of the parameter in which `val` is stored. Can be used for |
| * meta-programming of `Type` objects. |
| * @returns {string} Returns a string representation of `val` that can be encoded in a URL. |
| */ |
| Type.prototype.encode = function(val, key) { |
| return val; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:Type#decode |
| * @methodOf ui.router.util.type:Type |
| * |
| * @description |
| * Converts a parameter value (from URL string or transition param) to a custom/native value. |
| * |
| * @param {string} val The URL parameter value to decode. |
| * @param {string} key The name of the parameter in which `val` is stored. Can be used for |
| * meta-programming of `Type` objects. |
| * @returns {*} Returns a custom representation of the URL parameter value. |
| */ |
| Type.prototype.decode = function(val, key) { |
| return val; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.type:Type#equals |
| * @methodOf ui.router.util.type:Type |
| * |
| * @description |
| * Determines whether two decoded values are equivalent. |
| * |
| * @param {*} a A value to compare against. |
| * @param {*} b A value to compare against. |
| * @returns {Boolean} Returns `true` if the values are equivalent/equal, otherwise `false`. |
| */ |
| Type.prototype.equals = function(a, b) { |
| return a == b; |
| }; |
| |
| Type.prototype.$subPattern = function() { |
| var sub = this.pattern.toString(); |
| return sub.substr(1, sub.length - 2); |
| }; |
| |
| Type.prototype.pattern = /.*/; |
| |
| Type.prototype.toString = function() { return "{Type:" + this.name + "}"; }; |
| |
| /** Given an encoded string, or a decoded object, returns a decoded object */ |
| Type.prototype.$normalize = function(val) { |
| return this.is(val) ? val : this.decode(val); |
| }; |
| |
| /* |
| * Wraps an existing custom Type as an array of Type, depending on 'mode'. |
| * e.g.: |
| * - urlmatcher pattern "/path?{queryParam[]:int}" |
| * - url: "/path?queryParam=1&queryParam=2 |
| * - $stateParams.queryParam will be [1, 2] |
| * if `mode` is "auto", then |
| * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1 |
| * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2] |
| */ |
| Type.prototype.$asArray = function(mode, isSearch) { |
| if (!mode) return this; |
| if (mode === "auto" && !isSearch) throw new Error("'auto' array mode is for query parameters only"); |
| |
| function ArrayType(type, mode) { |
| function bindTo(type, callbackName) { |
| return function() { |
| return type[callbackName].apply(type, arguments); |
| }; |
| } |
| |
| // Wrap non-array value as array |
| function arrayWrap(val) { return isArray(val) ? val : (isDefined(val) ? [ val ] : []); } |
| // Unwrap array value for "auto" mode. Return undefined for empty array. |
| function arrayUnwrap(val) { |
| switch(val.length) { |
| case 0: return undefined; |
| case 1: return mode === "auto" ? val[0] : val; |
| default: return val; |
| } |
| } |
| function falsey(val) { return !val; } |
| |
| // Wraps type (.is/.encode/.decode) functions to operate on each value of an array |
| function arrayHandler(callback, allTruthyMode) { |
| return function handleArray(val) { |
| val = arrayWrap(val); |
| var result = map(val, callback); |
| if (allTruthyMode === true) |
| return filter(result, falsey).length === 0; |
| return arrayUnwrap(result); |
| }; |
| } |
| |
| // Wraps type (.equals) functions to operate on each value of an array |
| function arrayEqualsHandler(callback) { |
| return function handleArray(val1, val2) { |
| var left = arrayWrap(val1), right = arrayWrap(val2); |
| if (left.length !== right.length) return false; |
| for (var i = 0; i < left.length; i++) { |
| if (!callback(left[i], right[i])) return false; |
| } |
| return true; |
| }; |
| } |
| |
| this.encode = arrayHandler(bindTo(type, 'encode')); |
| this.decode = arrayHandler(bindTo(type, 'decode')); |
| this.is = arrayHandler(bindTo(type, 'is'), true); |
| this.equals = arrayEqualsHandler(bindTo(type, 'equals')); |
| this.pattern = type.pattern; |
| this.$normalize = arrayHandler(bindTo(type, '$normalize')); |
| this.name = type.name; |
| this.$arrayMode = mode; |
| } |
| |
| return new ArrayType(this, mode); |
| }; |
| |
| |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Factory for {@link ui.router.util.type:UrlMatcher `UrlMatcher`} instances. The factory |
| * is also available to providers under the name `$urlMatcherFactoryProvider`. |
| */ |
| function $UrlMatcherFactory() { |
| $$UMFP = this; |
| |
| var isCaseInsensitive = false, isStrictMode = true, defaultSquashPolicy = false; |
| |
| function valToString(val) { return val != null ? val.toString().replace(/\//g, "%2F") : val; } |
| function valFromString(val) { return val != null ? val.toString().replace(/%2F/g, "/") : val; } |
| |
| var $types = {}, enqueue = true, typeQueue = [], injector, defaultTypes = { |
| string: { |
| encode: valToString, |
| decode: valFromString, |
| // TODO: in 1.0, make string .is() return false if value is undefined/null by default. |
| // In 0.2.x, string params are optional by default for backwards compat |
| is: function(val) { return val == null || !isDefined(val) || typeof val === "string"; }, |
| pattern: /[^/]*/ |
| }, |
| int: { |
| encode: valToString, |
| decode: function(val) { return parseInt(val, 10); }, |
| is: function(val) { return isDefined(val) && this.decode(val.toString()) === val; }, |
| pattern: /\d+/ |
| }, |
| bool: { |
| encode: function(val) { return val ? 1 : 0; }, |
| decode: function(val) { return parseInt(val, 10) !== 0; }, |
| is: function(val) { return val === true || val === false; }, |
| pattern: /0|1/ |
| }, |
| date: { |
| encode: function (val) { |
| if (!this.is(val)) |
| return undefined; |
| return [ val.getFullYear(), |
| ('0' + (val.getMonth() + 1)).slice(-2), |
| ('0' + val.getDate()).slice(-2) |
| ].join("-"); |
| }, |
| decode: function (val) { |
| if (this.is(val)) return val; |
| var match = this.capture.exec(val); |
| return match ? new Date(match[1], match[2] - 1, match[3]) : undefined; |
| }, |
| is: function(val) { return val instanceof Date && !isNaN(val.valueOf()); }, |
| equals: function (a, b) { return this.is(a) && this.is(b) && a.toISOString() === b.toISOString(); }, |
| pattern: /[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/, |
| capture: /([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/ |
| }, |
| json: { |
| encode: angular.toJson, |
| decode: angular.fromJson, |
| is: angular.isObject, |
| equals: angular.equals, |
| pattern: /[^/]*/ |
| }, |
| any: { // does not encode/decode |
| encode: angular.identity, |
| decode: angular.identity, |
| equals: angular.equals, |
| pattern: /.*/ |
| } |
| }; |
| |
| function getDefaultConfig() { |
| return { |
| strict: isStrictMode, |
| caseInsensitive: isCaseInsensitive |
| }; |
| } |
| |
| function isInjectable(value) { |
| return (isFunction(value) || (isArray(value) && isFunction(value[value.length - 1]))); |
| } |
| |
| /** |
| * [Internal] Get the default value of a parameter, which may be an injectable function. |
| */ |
| $UrlMatcherFactory.$$getDefaultValue = function(config) { |
| if (!isInjectable(config.value)) return config.value; |
| if (!injector) throw new Error("Injectable functions cannot be called at configuration time"); |
| return injector.invoke(config.value); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$urlMatcherFactory#caseInsensitive |
| * @methodOf ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Defines whether URL matching should be case sensitive (the default behavior), or not. |
| * |
| * @param {boolean} value `false` to match URL in a case sensitive manner; otherwise `true`; |
| * @returns {boolean} the current value of caseInsensitive |
| */ |
| this.caseInsensitive = function(value) { |
| if (isDefined(value)) |
| isCaseInsensitive = value; |
| return isCaseInsensitive; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$urlMatcherFactory#strictMode |
| * @methodOf ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Defines whether URLs should match trailing slashes, or not (the default behavior). |
| * |
| * @param {boolean=} value `false` to match trailing slashes in URLs, otherwise `true`. |
| * @returns {boolean} the current value of strictMode |
| */ |
| this.strictMode = function(value) { |
| if (isDefined(value)) |
| isStrictMode = value; |
| return isStrictMode; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$urlMatcherFactory#defaultSquashPolicy |
| * @methodOf ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Sets the default behavior when generating or matching URLs with default parameter values. |
| * |
| * @param {string} value A string that defines the default parameter URL squashing behavior. |
| * `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL |
| * `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the |
| * parameter is surrounded by slashes, squash (remove) one slash from the URL |
| * any other string, e.g. "~": When generating an href with a default parameter value, squash (remove) |
| * the parameter value from the URL and replace it with this string. |
| */ |
| this.defaultSquashPolicy = function(value) { |
| if (!isDefined(value)) return defaultSquashPolicy; |
| if (value !== true && value !== false && !isString(value)) |
| throw new Error("Invalid squash policy: " + value + ". Valid policies: false, true, arbitrary-string"); |
| defaultSquashPolicy = value; |
| return value; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$urlMatcherFactory#compile |
| * @methodOf ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Creates a {@link ui.router.util.type:UrlMatcher `UrlMatcher`} for the specified pattern. |
| * |
| * @param {string} pattern The URL pattern. |
| * @param {Object} config The config object hash. |
| * @returns {UrlMatcher} The UrlMatcher. |
| */ |
| this.compile = function (pattern, config) { |
| return new UrlMatcher(pattern, extend(getDefaultConfig(), config)); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$urlMatcherFactory#isMatcher |
| * @methodOf ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Returns true if the specified object is a `UrlMatcher`, or false otherwise. |
| * |
| * @param {Object} object The object to perform the type check against. |
| * @returns {Boolean} Returns `true` if the object matches the `UrlMatcher` interface, by |
| * implementing all the same methods. |
| */ |
| this.isMatcher = function (o) { |
| if (!isObject(o)) return false; |
| var result = true; |
| |
| forEach(UrlMatcher.prototype, function(val, name) { |
| if (isFunction(val)) { |
| result = result && (isDefined(o[name]) && isFunction(o[name])); |
| } |
| }); |
| return result; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.util.$urlMatcherFactory#type |
| * @methodOf ui.router.util.$urlMatcherFactory |
| * |
| * @description |
| * Registers a custom {@link ui.router.util.type:Type `Type`} object that can be used to |
| * generate URLs with typed parameters. |
| * |
| * @param {string} name The type name. |
| * @param {Object|Function} definition The type definition. See |
| * {@link ui.router.util.type:Type `Type`} for information on the values accepted. |
| * @param {Object|Function} definitionFn (optional) A function that is injected before the app |
| * runtime starts. The result of this function is merged into the existing `definition`. |
| * See {@link ui.router.util.type:Type `Type`} for information on the values accepted. |
| * |
| * @returns {Object} Returns `$urlMatcherFactoryProvider`. |
| * |
| * @example |
| * This is a simple example of a custom type that encodes and decodes items from an |
| * array, using the array index as the URL-encoded value: |
| * |
| * <pre> |
| * var list = ['John', 'Paul', 'George', 'Ringo']; |
| * |
| * $urlMatcherFactoryProvider.type('listItem', { |
| * encode: function(item) { |
| * // Represent the list item in the URL using its corresponding index |
| * return list.indexOf(item); |
| * }, |
| * decode: function(item) { |
| * // Look up the list item by index |
| * return list[parseInt(item, 10)]; |
| * }, |
| * is: function(item) { |
| * // Ensure the item is valid by checking to see that it appears |
| * // in the list |
| * return list.indexOf(item) > -1; |
| * } |
| * }); |
| * |
| * $stateProvider.state('list', { |
| * url: "/list/{item:listItem}", |
| * controller: function($scope, $stateParams) { |
| * console.log($stateParams.item); |
| * } |
| * }); |
| * |
| * // ... |
| * |
| * // Changes URL to '/list/3', logs "Ringo" to the console |
| * $state.go('list', { item: "Ringo" }); |
| * </pre> |
| * |
| * This is a more complex example of a type that relies on dependency injection to |
| * interact with services, and uses the parameter name from the URL to infer how to |
| * handle encoding and decoding parameter values: |
| * |
| * <pre> |
| * // Defines a custom type that gets a value from a service, |
| * // where each service gets different types of values from |
| * // a backend API: |
| * $urlMatcherFactoryProvider.type('dbObject', {}, function(Users, Posts) { |
| * |
| * // Matches up services to URL parameter names |
| * var services = { |
| * user: Users, |
| * post: Posts |
| * }; |
| * |
| * return { |
| * encode: function(object) { |
| * // Represent the object in the URL using its unique ID |
| * return object.id; |
| * }, |
| * decode: function(value, key) { |
| * // Look up the object by ID, using the parameter |
| * // name (key) to call the correct service |
| * return services[key].findById(value); |
| * }, |
| * is: function(object, key) { |
| * // Check that object is a valid dbObject |
| * return angular.isObject(object) && object.id && services[key]; |
| * } |
| * equals: function(a, b) { |
| * // Check the equality of decoded objects by comparing |
| * // their unique IDs |
| * return a.id === b.id; |
| * } |
| * }; |
| * }); |
| * |
| * // In a config() block, you can then attach URLs with |
| * // type-annotated parameters: |
| * $stateProvider.state('users', { |
| * url: "/users", |
| * // ... |
| * }).state('users.item', { |
| * url: "/{user:dbObject}", |
| * controller: function($scope, $stateParams) { |
| * // $stateParams.user will now be an object returned from |
| * // the Users service |
| * }, |
| * // ... |
| * }); |
| * </pre> |
| */ |
| this.type = function (name, definition, definitionFn) { |
| if (!isDefined(definition)) return $types[name]; |
| if ($types.hasOwnProperty(name)) throw new Error("A type named '" + name + "' has already been defined."); |
| |
| $types[name] = new Type(extend({ name: name }, definition)); |
| if (definitionFn) { |
| typeQueue.push({ name: name, def: definitionFn }); |
| if (!enqueue) flushTypeQueue(); |
| } |
| return this; |
| }; |
| |
| // `flushTypeQueue()` waits until `$urlMatcherFactory` is injected before invoking the queued `definitionFn`s |
| function flushTypeQueue() { |
| while(typeQueue.length) { |
| var type = typeQueue.shift(); |
| if (type.pattern) throw new Error("You cannot override a type's .pattern at runtime."); |
| angular.extend($types[type.name], injector.invoke(type.def)); |
| } |
| } |
| |
| // Register default types. Store them in the prototype of $types. |
| forEach(defaultTypes, function(type, name) { $types[name] = new Type(extend({name: name}, type)); }); |
| $types = inherit($types, {}); |
| |
| /* No need to document $get, since it returns this */ |
| this.$get = ['$injector', function ($injector) { |
| injector = $injector; |
| enqueue = false; |
| flushTypeQueue(); |
| |
| forEach(defaultTypes, function(type, name) { |
| if (!$types[name]) $types[name] = new Type(type); |
| }); |
| return this; |
| }]; |
| |
| this.Param = function Param(id, type, config, location) { |
| var self = this; |
| config = unwrapShorthand(config); |
| type = getType(config, type, location); |
| var arrayMode = getArrayMode(); |
| type = arrayMode ? type.$asArray(arrayMode, location === "search") : type; |
| if (type.name === "string" && !arrayMode && location === "path" && config.value === undefined) |
| config.value = ""; // for 0.2.x; in 0.3.0+ do not automatically default to "" |
| var isOptional = config.value !== undefined; |
| var squash = getSquashPolicy(config, isOptional); |
| var replace = getReplace(config, arrayMode, isOptional, squash); |
| |
| function unwrapShorthand(config) { |
| var keys = isObject(config) ? objectKeys(config) : []; |
| var isShorthand = indexOf(keys, "value") === -1 && indexOf(keys, "type") === -1 && |
| indexOf(keys, "squash") === -1 && indexOf(keys, "array") === -1; |
| if (isShorthand) config = { value: config }; |
| config.$$fn = isInjectable(config.value) ? config.value : function () { return config.value; }; |
| return config; |
| } |
| |
| function getType(config, urlType, location) { |
| if (config.type && urlType) throw new Error("Param '"+id+"' has two type configurations."); |
| if (urlType) return urlType; |
| if (!config.type) return (location === "config" ? $types.any : $types.string); |
| return config.type instanceof Type ? config.type : new Type(config.type); |
| } |
| |
| // array config: param name (param[]) overrides default settings. explicit config overrides param name. |
| function getArrayMode() { |
| var arrayDefaults = { array: (location === "search" ? "auto" : false) }; |
| var arrayParamNomenclature = id.match(/\[\]$/) ? { array: true } : {}; |
| return extend(arrayDefaults, arrayParamNomenclature, config).array; |
| } |
| |
| /** |
| * returns false, true, or the squash value to indicate the "default parameter url squash policy". |
| */ |
| function getSquashPolicy(config, isOptional) { |
| var squash = config.squash; |
| if (!isOptional || squash === false) return false; |
| if (!isDefined(squash) || squash == null) return defaultSquashPolicy; |
| if (squash === true || isString(squash)) return squash; |
| throw new Error("Invalid squash policy: '" + squash + "'. Valid policies: false, true, or arbitrary string"); |
| } |
| |
| function getReplace(config, arrayMode, isOptional, squash) { |
| var replace, configuredKeys, defaultPolicy = [ |
| { from: "", to: (isOptional || arrayMode ? undefined : "") }, |
| { from: null, to: (isOptional || arrayMode ? undefined : "") } |
| ]; |
| replace = isArray(config.replace) ? config.replace : []; |
| if (isString(squash)) |
| replace.push({ from: squash, to: undefined }); |
| configuredKeys = map(replace, function(item) { return item.from; } ); |
| return filter(defaultPolicy, function(item) { return indexOf(configuredKeys, item.from) === -1; }).concat(replace); |
| } |
| |
| /** |
| * [Internal] Get the default value of a parameter, which may be an injectable function. |
| */ |
| function $$getDefaultValue() { |
| if (!injector) throw new Error("Injectable functions cannot be called at configuration time"); |
| var defaultValue = injector.invoke(config.$$fn); |
| if (defaultValue !== null && defaultValue !== undefined && !self.type.is(defaultValue)) |
| throw new Error("Default value (" + defaultValue + ") for parameter '" + self.id + "' is not an instance of Type (" + self.type.name + ")"); |
| return defaultValue; |
| } |
| |
| /** |
| * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the |
| * default value, which may be the result of an injectable function. |
| */ |
| function $value(value) { |
| function hasReplaceVal(val) { return function(obj) { return obj.from === val; }; } |
| function $replace(value) { |
| var replacement = map(filter(self.replace, hasReplaceVal(value)), function(obj) { return obj.to; }); |
| return replacement.length ? replacement[0] : value; |
| } |
| value = $replace(value); |
| return !isDefined(value) ? $$getDefaultValue() : self.type.$normalize(value); |
| } |
| |
| function toString() { return "{Param:" + id + " " + type + " squash: '" + squash + "' optional: " + isOptional + "}"; } |
| |
| extend(this, { |
| id: id, |
| type: type, |
| location: location, |
| array: arrayMode, |
| squash: squash, |
| replace: replace, |
| isOptional: isOptional, |
| value: $value, |
| dynamic: undefined, |
| config: config, |
| toString: toString |
| }); |
| }; |
| |
| function ParamSet(params) { |
| extend(this, params || {}); |
| } |
| |
| ParamSet.prototype = { |
| $$new: function() { |
| return inherit(this, extend(new ParamSet(), { $$parent: this})); |
| }, |
| $$keys: function () { |
| var keys = [], chain = [], parent = this, |
| ignore = objectKeys(ParamSet.prototype); |
| while (parent) { chain.push(parent); parent = parent.$$parent; } |
| chain.reverse(); |
| forEach(chain, function(paramset) { |
| forEach(objectKeys(paramset), function(key) { |
| if (indexOf(keys, key) === -1 && indexOf(ignore, key) === -1) keys.push(key); |
| }); |
| }); |
| return keys; |
| }, |
| $$values: function(paramValues) { |
| var values = {}, self = this; |
| forEach(self.$$keys(), function(key) { |
| values[key] = self[key].value(paramValues && paramValues[key]); |
| }); |
| return values; |
| }, |
| $$equals: function(paramValues1, paramValues2) { |
| var equal = true, self = this; |
| forEach(self.$$keys(), function(key) { |
| var left = paramValues1 && paramValues1[key], right = paramValues2 && paramValues2[key]; |
| if (!self[key].type.equals(left, right)) equal = false; |
| }); |
| return equal; |
| }, |
| $$validates: function $$validate(paramValues) { |
| var keys = this.$$keys(), i, param, rawVal, normalized, encoded; |
| for (i = 0; i < keys.length; i++) { |
| param = this[keys[i]]; |
| rawVal = paramValues[keys[i]]; |
| if ((rawVal === undefined || rawVal === null) && param.isOptional) |
| break; // There was no parameter value, but the param is optional |
| normalized = param.type.$normalize(rawVal); |
| if (!param.type.is(normalized)) |
| return false; // The value was not of the correct Type, and could not be decoded to the correct Type |
| encoded = param.type.encode(normalized); |
| if (angular.isString(encoded) && !param.type.pattern.exec(encoded)) |
| return false; // The value was of the correct type, but when encoded, did not match the Type's regexp |
| } |
| return true; |
| }, |
| $$parent: undefined |
| }; |
| |
| this.ParamSet = ParamSet; |
| } |
| |
| // Register as a provider so it's available to other providers |
| angular.module('ui.router.util').provider('$urlMatcherFactory', $UrlMatcherFactory); |
| angular.module('ui.router.util').run(['$urlMatcherFactory', function($urlMatcherFactory) { }]); |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.router.$urlRouterProvider |
| * |
| * @requires ui.router.util.$urlMatcherFactoryProvider |
| * @requires $locationProvider |
| * |
| * @description |
| * `$urlRouterProvider` has the responsibility of watching `$location`. |
| * When `$location` changes it runs through a list of rules one by one until a |
| * match is found. `$urlRouterProvider` is used behind the scenes anytime you specify |
| * a url in a state configuration. All urls are compiled into a UrlMatcher object. |
| * |
| * There are several methods on `$urlRouterProvider` that make it useful to use directly |
| * in your module config. |
| */ |
| $UrlRouterProvider.$inject = ['$locationProvider', '$urlMatcherFactoryProvider']; |
| function $UrlRouterProvider( $locationProvider, $urlMatcherFactory) { |
| var rules = [], otherwise = null, interceptDeferred = false, listener; |
| |
| // Returns a string that is a prefix of all strings matching the RegExp |
| function regExpPrefix(re) { |
| var prefix = /^\^((?:\\[^a-zA-Z0-9]|[^\\\[\]\^$*+?.()|{}]+)*)/.exec(re.source); |
| return (prefix != null) ? prefix[1].replace(/\\(.)/g, "$1") : ''; |
| } |
| |
| // Interpolates matched values into a String.replace()-style pattern |
| function interpolate(pattern, match) { |
| return pattern.replace(/\$(\$|\d{1,2})/, function (m, what) { |
| return match[what === '$' ? 0 : Number(what)]; |
| }); |
| } |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.router.$urlRouterProvider#rule |
| * @methodOf ui.router.router.$urlRouterProvider |
| * |
| * @description |
| * Defines rules that are used by `$urlRouterProvider` to find matches for |
| * specific URLs. |
| * |
| * @example |
| * <pre> |
| * var app = angular.module('app', ['ui.router.router']); |
| * |
| * app.config(function ($urlRouterProvider) { |
| * // Here's an example of how you might allow case insensitive urls |
| * $urlRouterProvider.rule(function ($injector, $location) { |
| * var path = $location.path(), |
| * normalized = path.toLowerCase(); |
| * |
| * if (path !== normalized) { |
| * return normalized; |
| * } |
| * }); |
| * }); |
| * </pre> |
| * |
| * @param {object} rule Handler function that takes `$injector` and `$location` |
| * services as arguments. You can use them to return a valid path as a string. |
| * |
| * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance |
| */ |
| this.rule = function (rule) { |
| if (!isFunction(rule)) throw new Error("'rule' must be a function"); |
| rules.push(rule); |
| return this; |
| }; |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.router.$urlRouterProvider#otherwise |
| * @methodOf ui.router.router.$urlRouterProvider |
| * |
| * @description |
| * Defines a path that is used when an invalid route is requested. |
| * |
| * @example |
| * <pre> |
| * var app = angular.module('app', ['ui.router.router']); |
| * |
| * app.config(function ($urlRouterProvider) { |
| * // if the path doesn't match any of the urls you configured |
| * // otherwise will take care of routing the user to the |
| * // specified url |
| * $urlRouterProvider.otherwise('/index'); |
| * |
| * // Example of using function rule as param |
| * $urlRouterProvider.otherwise(function ($injector, $location) { |
| * return '/a/valid/url'; |
| * }); |
| * }); |
| * </pre> |
| * |
| * @param {string|object} rule The url path you want to redirect to or a function |
| * rule that returns the url path. The function version is passed two params: |
| * `$injector` and `$location` services, and must return a url string. |
| * |
| * @return {object} `$urlRouterProvider` - `$urlRouterProvider` instance |
| */ |
| this.otherwise = function (rule) { |
| if (isString(rule)) { |
| var redirect = rule; |
| rule = function () { return redirect; }; |
| } |
| else if (!isFunction(rule)) throw new Error("'rule' must be a function"); |
| otherwise = rule; |
| return this; |
| }; |
| |
| |
| function handleIfMatch($injector, handler, match) { |
| if (!match) return false; |
| var result = $injector.invoke(handler, handler, { $match: match }); |
| return isDefined(result) ? result : true; |
| } |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.router.$urlRouterProvider#when |
| * @methodOf ui.router.router.$urlRouterProvider |
| * |
| * @description |
| * Registers a handler for a given url matching. if handle is a string, it is |
| * treated as a redirect, and is interpolated according to the syntax of match |
| * (i.e. like `String.replace()` for `RegExp`, or like a `UrlMatcher` pattern otherwise). |
| * |
| * If the handler is a function, it is injectable. It gets invoked if `$location` |
| * matches. You have the option of inject the match object as `$match`. |
| * |
| * The handler can return |
| * |
| * - **falsy** to indicate that the rule didn't match after all, then `$urlRouter` |
| * will continue trying to find another one that matches. |
| * - **string** which is treated as a redirect and passed to `$location.url()` |
| * - **void** or any **truthy** value tells `$urlRouter` that the url was handled. |
| * |
| * @example |
| * <pre> |
| * var app = angular.module('app', ['ui.router.router']); |
| * |
| * app.config(function ($urlRouterProvider) { |
| * $urlRouterProvider.when($state.url, function ($match, $stateParams) { |
| * if ($state.$current.navigable !== state || |
| * !equalForKeys($match, $stateParams) { |
| * $state.transitionTo(state, $match, false); |
| * } |
| * }); |
| * }); |
| * </pre> |
| * |
| * @param {string|object} what The incoming path that you want to redirect. |
| * @param {string|object} handler The path you want to redirect your user to. |
| */ |
| this.when = function (what, handler) { |
| var redirect, handlerIsString = isString(handler); |
| if (isString(what)) what = $urlMatcherFactory.compile(what); |
| |
| if (!handlerIsString && !isFunction(handler) && !isArray(handler)) |
| throw new Error("invalid 'handler' in when()"); |
| |
| var strategies = { |
| matcher: function (what, handler) { |
| if (handlerIsString) { |
| redirect = $urlMatcherFactory.compile(handler); |
| handler = ['$match', function ($match) { return redirect.format($match); }]; |
| } |
| return extend(function ($injector, $location) { |
| return handleIfMatch($injector, handler, what.exec($location.path(), $location.search())); |
| }, { |
| prefix: isString(what.prefix) ? what.prefix : '' |
| }); |
| }, |
| regex: function (what, handler) { |
| if (what.global || what.sticky) throw new Error("when() RegExp must not be global or sticky"); |
| |
| if (handlerIsString) { |
| redirect = handler; |
| handler = ['$match', function ($match) { return interpolate(redirect, $match); }]; |
| } |
| return extend(function ($injector, $location) { |
| return handleIfMatch($injector, handler, what.exec($location.path())); |
| }, { |
| prefix: regExpPrefix(what) |
| }); |
| } |
| }; |
| |
| var check = { matcher: $urlMatcherFactory.isMatcher(what), regex: what instanceof RegExp }; |
| |
| for (var n in check) { |
| if (check[n]) return this.rule(strategies[n](what, handler)); |
| } |
| |
| throw new Error("invalid 'what' in when()"); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.router.$urlRouterProvider#deferIntercept |
| * @methodOf ui.router.router.$urlRouterProvider |
| * |
| * @description |
| * Disables (or enables) deferring location change interception. |
| * |
| * If you wish to customize the behavior of syncing the URL (for example, if you wish to |
| * defer a transition but maintain the current URL), call this method at configuration time. |
| * Then, at run time, call `$urlRouter.listen()` after you have configured your own |
| * `$locationChangeSuccess` event handler. |
| * |
| * @example |
| * <pre> |
| * var app = angular.module('app', ['ui.router.router']); |
| * |
| * app.config(function ($urlRouterProvider) { |
| * |
| * // Prevent $urlRouter from automatically intercepting URL changes; |
| * // this allows you to configure custom behavior in between |
| * // location changes and route synchronization: |
| * $urlRouterProvider.deferIntercept(); |
| * |
| * }).run(function ($rootScope, $urlRouter, UserService) { |
| * |
| * $rootScope.$on('$locationChangeSuccess', function(e) { |
| * // UserService is an example service for managing user state |
| * if (UserService.isLoggedIn()) return; |
| * |
| * // Prevent $urlRouter's default handler from firing |
| * e.preventDefault(); |
| * |
| * UserService.handleLogin().then(function() { |
| * // Once the user has logged in, sync the current URL |
| * // to the router: |
| * $urlRouter.sync(); |
| * }); |
| * }); |
| * |
| * // Configures $urlRouter's listener *after* your custom listener |
| * $urlRouter.listen(); |
| * }); |
| * </pre> |
| * |
| * @param {boolean} defer Indicates whether to defer location change interception. Passing |
| no parameter is equivalent to `true`. |
| */ |
| this.deferIntercept = function (defer) { |
| if (defer === undefined) defer = true; |
| interceptDeferred = defer; |
| }; |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.router.$urlRouter |
| * |
| * @requires $location |
| * @requires $rootScope |
| * @requires $injector |
| * @requires $browser |
| * |
| * @description |
| * |
| */ |
| this.$get = $get; |
| $get.$inject = ['$location', '$rootScope', '$injector', '$browser']; |
| function $get( $location, $rootScope, $injector, $browser) { |
| |
| var baseHref = $browser.baseHref(), location = $location.url(), lastPushedUrl; |
| |
| function appendBasePath(url, isHtml5, absolute) { |
| if (baseHref === '/') return url; |
| if (isHtml5) return baseHref.slice(0, -1) + url; |
| if (absolute) return baseHref.slice(1) + url; |
| return url; |
| } |
| |
| // TODO: Optimize groups of rules with non-empty prefix into some sort of decision tree |
| function update(evt) { |
| if (evt && evt.defaultPrevented) return; |
| var ignoreUpdate = lastPushedUrl && $location.url() === lastPushedUrl; |
| lastPushedUrl = undefined; |
| // TODO: Re-implement this in 1.0 for https://github.com/angular-ui/ui-router/issues/1573 |
| //if (ignoreUpdate) return true; |
| |
| function check(rule) { |
| var handled = rule($injector, $location); |
| |
| if (!handled) return false; |
| if (isString(handled)) $location.replace().url(handled); |
| return true; |
| } |
| var n = rules.length, i; |
| |
| for (i = 0; i < n; i++) { |
| if (check(rules[i])) return; |
| } |
| // always check otherwise last to allow dynamic updates to the set of rules |
| if (otherwise) check(otherwise); |
| } |
| |
| function listen() { |
| listener = listener || $rootScope.$on('$locationChangeSuccess', update); |
| return listener; |
| } |
| |
| if (!interceptDeferred) listen(); |
| |
| return { |
| /** |
| * @ngdoc function |
| * @name ui.router.router.$urlRouter#sync |
| * @methodOf ui.router.router.$urlRouter |
| * |
| * @description |
| * Triggers an update; the same update that happens when the address bar url changes, aka `$locationChangeSuccess`. |
| * This method is useful when you need to use `preventDefault()` on the `$locationChangeSuccess` event, |
| * perform some custom logic (route protection, auth, config, redirection, etc) and then finally proceed |
| * with the transition by calling `$urlRouter.sync()`. |
| * |
| * @example |
| * <pre> |
| * angular.module('app', ['ui.router']) |
| * .run(function($rootScope, $urlRouter) { |
| * $rootScope.$on('$locationChangeSuccess', function(evt) { |
| * // Halt state change from even starting |
| * evt.preventDefault(); |
| * // Perform custom logic |
| * var meetsRequirement = ... |
| * // Continue with the update and state transition if logic allows |
| * if (meetsRequirement) $urlRouter.sync(); |
| * }); |
| * }); |
| * </pre> |
| */ |
| sync: function() { |
| update(); |
| }, |
| |
| listen: function() { |
| return listen(); |
| }, |
| |
| update: function(read) { |
| if (read) { |
| location = $location.url(); |
| return; |
| } |
| if ($location.url() === location) return; |
| |
| $location.url(location); |
| $location.replace(); |
| }, |
| |
| push: function(urlMatcher, params, options) { |
| var url = urlMatcher.format(params || {}); |
| |
| // Handle the special hash param, if needed |
| if (url !== null && params && params['#']) { |
| url += '#' + params['#']; |
| } |
| |
| $location.url(url); |
| lastPushedUrl = options && options.$$avoidResync ? $location.url() : undefined; |
| if (options && options.replace) $location.replace(); |
| }, |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.router.$urlRouter#href |
| * @methodOf ui.router.router.$urlRouter |
| * |
| * @description |
| * A URL generation method that returns the compiled URL for a given |
| * {@link ui.router.util.type:UrlMatcher `UrlMatcher`}, populated with the provided parameters. |
| * |
| * @example |
| * <pre> |
| * $bob = $urlRouter.href(new UrlMatcher("/about/:person"), { |
| * person: "bob" |
| * }); |
| * // $bob == "/about/bob"; |
| * </pre> |
| * |
| * @param {UrlMatcher} urlMatcher The `UrlMatcher` object which is used as the template of the URL to generate. |
| * @param {object=} params An object of parameter values to fill the matcher's required parameters. |
| * @param {object=} options Options object. The options are: |
| * |
| * - **`absolute`** - {boolean=false}, If true will generate an absolute url, e.g. "http://www.example.com/fullurl". |
| * |
| * @returns {string} Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher` |
| */ |
| href: function(urlMatcher, params, options) { |
| if (!urlMatcher.validates(params)) return null; |
| |
| var isHtml5 = $locationProvider.html5Mode(); |
| if (angular.isObject(isHtml5)) { |
| isHtml5 = isHtml5.enabled; |
| } |
| |
| var url = urlMatcher.format(params); |
| options = options || {}; |
| |
| if (!isHtml5 && url !== null) { |
| url = "#" + $locationProvider.hashPrefix() + url; |
| } |
| |
| // Handle special hash param, if needed |
| if (url !== null && params && params['#']) { |
| url += '#' + params['#']; |
| } |
| |
| url = appendBasePath(url, isHtml5, options.absolute); |
| |
| if (!options.absolute || !url) { |
| return url; |
| } |
| |
| var slash = (!isHtml5 && url ? '/' : ''), port = $location.port(); |
| port = (port === 80 || port === 443 ? '' : ':' + port); |
| |
| return [$location.protocol(), '://', $location.host(), port, slash, url].join(''); |
| } |
| }; |
| } |
| } |
| |
| angular.module('ui.router.router').provider('$urlRouter', $UrlRouterProvider); |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.state.$stateProvider |
| * |
| * @requires ui.router.router.$urlRouterProvider |
| * @requires ui.router.util.$urlMatcherFactoryProvider |
| * |
| * @description |
| * The new `$stateProvider` works similar to Angular's v1 router, but it focuses purely |
| * on state. |
| * |
| * A state corresponds to a "place" in the application in terms of the overall UI and |
| * navigation. A state describes (via the controller / template / view properties) what |
| * the UI looks like and does at that place. |
| * |
| * States often have things in common, and the primary way of factoring out these |
| * commonalities in this model is via the state hierarchy, i.e. parent/child states aka |
| * nested states. |
| * |
| * The `$stateProvider` provides interfaces to declare these states for your app. |
| */ |
| $StateProvider.$inject = ['$urlRouterProvider', '$urlMatcherFactoryProvider']; |
| function $StateProvider( $urlRouterProvider, $urlMatcherFactory) { |
| |
| var root, states = {}, $state, queue = {}, abstractKey = 'abstract'; |
| |
| // Builds state properties from definition passed to registerState() |
| var stateBuilder = { |
| |
| // Derive parent state from a hierarchical name only if 'parent' is not explicitly defined. |
| // state.children = []; |
| // if (parent) parent.children.push(state); |
| parent: function(state) { |
| if (isDefined(state.parent) && state.parent) return findState(state.parent); |
| // regex matches any valid composite state name |
| // would match "contact.list" but not "contacts" |
| var compositeName = /^(.+)\.[^.]+$/.exec(state.name); |
| return compositeName ? findState(compositeName[1]) : root; |
| }, |
| |
| // inherit 'data' from parent and override by own values (if any) |
| data: function(state) { |
| if (state.parent && state.parent.data) { |
| state.data = state.self.data = extend({}, state.parent.data, state.data); |
| } |
| return state.data; |
| }, |
| |
| // Build a URLMatcher if necessary, either via a relative or absolute URL |
| url: function(state) { |
| var url = state.url, config = { params: state.params || {} }; |
| |
| if (isString(url)) { |
| if (url.charAt(0) == '^') return $urlMatcherFactory.compile(url.substring(1), config); |
| return (state.parent.navigable || root).url.concat(url, config); |
| } |
| |
| if (!url || $urlMatcherFactory.isMatcher(url)) return url; |
| throw new Error("Invalid url '" + url + "' in state '" + state + "'"); |
| }, |
| |
| // Keep track of the closest ancestor state that has a URL (i.e. is navigable) |
| navigable: function(state) { |
| return state.url ? state : (state.parent ? state.parent.navigable : null); |
| }, |
| |
| // Own parameters for this state. state.url.params is already built at this point. Create and add non-url params |
| ownParams: function(state) { |
| var params = state.url && state.url.params || new $$UMFP.ParamSet(); |
| forEach(state.params || {}, function(config, id) { |
| if (!params[id]) params[id] = new $$UMFP.Param(id, null, config, "config"); |
| }); |
| return params; |
| }, |
| |
| // Derive parameters for this state and ensure they're a super-set of parent's parameters |
| params: function(state) { |
| return state.parent && state.parent.params ? extend(state.parent.params.$$new(), state.ownParams) : new $$UMFP.ParamSet(); |
| }, |
| |
| // If there is no explicit multi-view configuration, make one up so we don't have |
| // to handle both cases in the view directive later. Note that having an explicit |
| // 'views' property will mean the default unnamed view properties are ignored. This |
| // is also a good time to resolve view names to absolute names, so everything is a |
| // straight lookup at link time. |
| views: function(state) { |
| var views = {}; |
| |
| forEach(isDefined(state.views) ? state.views : { '': state }, function (view, name) { |
| if (name.indexOf('@') < 0) name += '@' + state.parent.name; |
| views[name] = view; |
| }); |
| return views; |
| }, |
| |
| // Keep a full path from the root down to this state as this is needed for state activation. |
| path: function(state) { |
| return state.parent ? state.parent.path.concat(state) : []; // exclude root from path |
| }, |
| |
| // Speed up $state.contains() as it's used a lot |
| includes: function(state) { |
| var includes = state.parent ? extend({}, state.parent.includes) : {}; |
| includes[state.name] = true; |
| return includes; |
| }, |
| |
| $delegates: {} |
| }; |
| |
| function isRelative(stateName) { |
| return stateName.indexOf(".") === 0 || stateName.indexOf("^") === 0; |
| } |
| |
| function findState(stateOrName, base) { |
| if (!stateOrName) return undefined; |
| |
| var isStr = isString(stateOrName), |
| name = isStr ? stateOrName : stateOrName.name, |
| path = isRelative(name); |
| |
| if (path) { |
| if (!base) throw new Error("No reference point given for path '" + name + "'"); |
| base = findState(base); |
| |
| var rel = name.split("."), i = 0, pathLength = rel.length, current = base; |
| |
| for (; i < pathLength; i++) { |
| if (rel[i] === "" && i === 0) { |
| current = base; |
| continue; |
| } |
| if (rel[i] === "^") { |
| if (!current.parent) throw new Error("Path '" + name + "' not valid for state '" + base.name + "'"); |
| current = current.parent; |
| continue; |
| } |
| break; |
| } |
| rel = rel.slice(i).join("."); |
| name = current.name + (current.name && rel ? "." : "") + rel; |
| } |
| var state = states[name]; |
| |
| if (state && (isStr || (!isStr && (state === stateOrName || state.self === stateOrName)))) { |
| return state; |
| } |
| return undefined; |
| } |
| |
| function queueState(parentName, state) { |
| if (!queue[parentName]) { |
| queue[parentName] = []; |
| } |
| queue[parentName].push(state); |
| } |
| |
| function flushQueuedChildren(parentName) { |
| var queued = queue[parentName] || []; |
| while(queued.length) { |
| registerState(queued.shift()); |
| } |
| } |
| |
| function registerState(state) { |
| // Wrap a new object around the state so we can store our private details easily. |
| state = inherit(state, { |
| self: state, |
| resolve: state.resolve || {}, |
| toString: function() { return this.name; } |
| }); |
| |
| var name = state.name; |
| if (!isString(name) || name.indexOf('@') >= 0) throw new Error("State must have a valid name"); |
| if (states.hasOwnProperty(name)) throw new Error("State '" + name + "'' is already defined"); |
| |
| // Get parent name |
| var parentName = (name.indexOf('.') !== -1) ? name.substring(0, name.lastIndexOf('.')) |
| : (isString(state.parent)) ? state.parent |
| : (isObject(state.parent) && isString(state.parent.name)) ? state.parent.name |
| : ''; |
| |
| // If parent is not registered yet, add state to queue and register later |
| if (parentName && !states[parentName]) { |
| return queueState(parentName, state.self); |
| } |
| |
| for (var key in stateBuilder) { |
| if (isFunction(stateBuilder[key])) state[key] = stateBuilder[key](state, stateBuilder.$delegates[key]); |
| } |
| states[name] = state; |
| |
| // Register the state in the global state list and with $urlRouter if necessary. |
| if (!state[abstractKey] && state.url) { |
| $urlRouterProvider.when(state.url, ['$match', '$stateParams', function ($match, $stateParams) { |
| if ($state.$current.navigable != state || !equalForKeys($match, $stateParams)) { |
| $state.transitionTo(state, $match, { inherit: true, location: false }); |
| } |
| }]); |
| } |
| |
| // Register any queued children |
| flushQueuedChildren(name); |
| |
| return state; |
| } |
| |
| // Checks text to see if it looks like a glob. |
| function isGlob (text) { |
| return text.indexOf('*') > -1; |
| } |
| |
| // Returns true if glob matches current $state name. |
| function doesStateMatchGlob (glob) { |
| var globSegments = glob.split('.'), |
| segments = $state.$current.name.split('.'); |
| |
| //match single stars |
| for (var i = 0, l = globSegments.length; i < l; i++) { |
| if (globSegments[i] === '*') { |
| segments[i] = '*'; |
| } |
| } |
| |
| //match greedy starts |
| if (globSegments[0] === '**') { |
| segments = segments.slice(indexOf(segments, globSegments[1])); |
| segments.unshift('**'); |
| } |
| //match greedy ends |
| if (globSegments[globSegments.length - 1] === '**') { |
| segments.splice(indexOf(segments, globSegments[globSegments.length - 2]) + 1, Number.MAX_VALUE); |
| segments.push('**'); |
| } |
| |
| if (globSegments.length != segments.length) { |
| return false; |
| } |
| |
| return segments.join('') === globSegments.join(''); |
| } |
| |
| |
| // Implicit root state that is always active |
| root = registerState({ |
| name: '', |
| url: '^', |
| views: null, |
| 'abstract': true |
| }); |
| root.navigable = null; |
| |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$stateProvider#decorator |
| * @methodOf ui.router.state.$stateProvider |
| * |
| * @description |
| * Allows you to extend (carefully) or override (at your own peril) the |
| * `stateBuilder` object used internally by `$stateProvider`. This can be used |
| * to add custom functionality to ui-router, for example inferring templateUrl |
| * based on the state name. |
| * |
| * When passing only a name, it returns the current (original or decorated) builder |
| * function that matches `name`. |
| * |
| * The builder functions that can be decorated are listed below. Though not all |
| * necessarily have a good use case for decoration, that is up to you to decide. |
| * |
| * In addition, users can attach custom decorators, which will generate new |
| * properties within the state's internal definition. There is currently no clear |
| * use-case for this beyond accessing internal states (i.e. $state.$current), |
| * however, expect this to become increasingly relevant as we introduce additional |
| * meta-programming features. |
| * |
| * **Warning**: Decorators should not be interdependent because the order of |
| * execution of the builder functions in non-deterministic. Builder functions |
| * should only be dependent on the state definition object and super function. |
| * |
| * |
| * Existing builder functions and current return values: |
| * |
| * - **parent** `{object}` - returns the parent state object. |
| * - **data** `{object}` - returns state data, including any inherited data that is not |
| * overridden by own values (if any). |
| * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher} |
| * or `null`. |
| * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is |
| * navigable). |
| * - **params** `{object}` - returns an array of state params that are ensured to |
| * be a super-set of parent's params. |
| * - **views** `{object}` - returns a views object where each key is an absolute view |
| * name (i.e. "viewName@stateName") and each value is the config object |
| * (template, controller) for the view. Even when you don't use the views object |
| * explicitly on a state config, one is still created for you internally. |
| * So by decorating this builder function you have access to decorating template |
| * and controller properties. |
| * - **ownParams** `{object}` - returns an array of params that belong to the state, |
| * not including any params defined by ancestor states. |
| * - **path** `{string}` - returns the full path from the root down to this state. |
| * Needed for state activation. |
| * - **includes** `{object}` - returns an object that includes every state that |
| * would pass a `$state.includes()` test. |
| * |
| * @example |
| * <pre> |
| * // Override the internal 'views' builder with a function that takes the state |
| * // definition, and a reference to the internal function being overridden: |
| * $stateProvider.decorator('views', function (state, parent) { |
| * var result = {}, |
| * views = parent(state); |
| * |
| * angular.forEach(views, function (config, name) { |
| * var autoName = (state.name + '.' + name).replace('.', '/'); |
| * config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html'; |
| * result[name] = config; |
| * }); |
| * return result; |
| * }); |
| * |
| * $stateProvider.state('home', { |
| * views: { |
| * 'contact.list': { controller: 'ListController' }, |
| * 'contact.item': { controller: 'ItemController' } |
| * } |
| * }); |
| * |
| * // ... |
| * |
| * $state.go('home'); |
| * // Auto-populates list and item views with /partials/home/contact/list.html, |
| * // and /partials/home/contact/item.html, respectively. |
| * </pre> |
| * |
| * @param {string} name The name of the builder function to decorate. |
| * @param {object} func A function that is responsible for decorating the original |
| * builder function. The function receives two parameters: |
| * |
| * - `{object}` - state - The state config object. |
| * - `{object}` - super - The original builder function. |
| * |
| * @return {object} $stateProvider - $stateProvider instance |
| */ |
| this.decorator = decorator; |
| function decorator(name, func) { |
| /*jshint validthis: true */ |
| if (isString(name) && !isDefined(func)) { |
| return stateBuilder[name]; |
| } |
| if (!isFunction(func) || !isString(name)) { |
| return this; |
| } |
| if (stateBuilder[name] && !stateBuilder.$delegates[name]) { |
| stateBuilder.$delegates[name] = stateBuilder[name]; |
| } |
| stateBuilder[name] = func; |
| return this; |
| } |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$stateProvider#state |
| * @methodOf ui.router.state.$stateProvider |
| * |
| * @description |
| * Registers a state configuration under a given state name. The stateConfig object |
| * has the following acceptable properties. |
| * |
| * @param {string} name A unique state name, e.g. "home", "about", "contacts". |
| * To create a parent/child state use a dot, e.g. "about.sales", "home.newest". |
| * @param {object} stateConfig State configuration object. |
| * @param {string|function=} stateConfig.template |
| * <a id='template'></a> |
| * html template as a string or a function that returns |
| * an html template as a string which should be used by the uiView directives. This property |
| * takes precedence over templateUrl. |
| * |
| * If `template` is a function, it will be called with the following parameters: |
| * |
| * - {array.<object>} - state parameters extracted from the current $location.path() by |
| * applying the current state |
| * |
| * <pre>template: |
| * "<h1>inline template definition</h1>" + |
| * "<div ui-view></div>"</pre> |
| * <pre>template: function(params) { |
| * return "<h1>generated template</h1>"; }</pre> |
| * </div> |
| * |
| * @param {string|function=} stateConfig.templateUrl |
| * <a id='templateUrl'></a> |
| * |
| * path or function that returns a path to an html |
| * template that should be used by uiView. |
| * |
| * If `templateUrl` is a function, it will be called with the following parameters: |
| * |
| * - {array.<object>} - state parameters extracted from the current $location.path() by |
| * applying the current state |
| * |
| * <pre>templateUrl: "home.html"</pre> |
| * <pre>templateUrl: function(params) { |
| * return myTemplates[params.pageId]; }</pre> |
| * |
| * @param {function=} stateConfig.templateProvider |
| * <a id='templateProvider'></a> |
| * Provider function that returns HTML content string. |
| * <pre> templateProvider: |
| * function(MyTemplateService, params) { |
| * return MyTemplateService.getTemplate(params.pageId); |
| * }</pre> |
| * |
| * @param {string|function=} stateConfig.controller |
| * <a id='controller'></a> |
| * |
| * Controller fn that should be associated with newly |
| * related scope or the name of a registered controller if passed as a string. |
| * Optionally, the ControllerAs may be declared here. |
| * <pre>controller: "MyRegisteredController"</pre> |
| * <pre>controller: |
| * "MyRegisteredController as fooCtrl"}</pre> |
| * <pre>controller: function($scope, MyService) { |
| * $scope.data = MyService.getData(); }</pre> |
| * |
| * @param {function=} stateConfig.controllerProvider |
| * <a id='controllerProvider'></a> |
| * |
| * Injectable provider function that returns the actual controller or string. |
| * <pre>controllerProvider: |
| * function(MyResolveData) { |
| * if (MyResolveData.foo) |
| * return "FooCtrl" |
| * else if (MyResolveData.bar) |
| * return "BarCtrl"; |
| * else return function($scope) { |
| * $scope.baz = "Qux"; |
| * } |
| * }</pre> |
| * |
| * @param {string=} stateConfig.controllerAs |
| * <a id='controllerAs'></a> |
| * |
| * A controller alias name. If present the controller will be |
| * published to scope under the controllerAs name. |
| * <pre>controllerAs: "myCtrl"</pre> |
| * |
| * @param {string|object=} stateConfig.parent |
| * <a id='parent'></a> |
| * Optionally specifies the parent state of this state. |
| * |
| * <pre>parent: 'parentState'</pre> |
| * <pre>parent: parentState // JS variable</pre> |
| * |
| * @param {object=} stateConfig.resolve |
| * <a id='resolve'></a> |
| * |
| * An optional map<string, function> of dependencies which |
| * should be injected into the controller. If any of these dependencies are promises, |
| * the router will wait for them all to be resolved before the controller is instantiated. |
| * If all the promises are resolved successfully, the $stateChangeSuccess event is fired |
| * and the values of the resolved promises are injected into any controllers that reference them. |
| * If any of the promises are rejected the $stateChangeError event is fired. |
| * |
| * The map object is: |
| * |
| * - key - {string}: name of dependency to be injected into controller |
| * - factory - {string|function}: If string then it is alias for service. Otherwise if function, |
| * it is injected and return value it treated as dependency. If result is a promise, it is |
| * resolved before its value is injected into controller. |
| * |
| * <pre>resolve: { |
| * myResolve1: |
| * function($http, $stateParams) { |
| * return $http.get("/api/foos/"+stateParams.fooID); |
| * } |
| * }</pre> |
| * |
| * @param {string=} stateConfig.url |
| * <a id='url'></a> |
| * |
| * A url fragment with optional parameters. When a state is navigated or |
| * transitioned to, the `$stateParams` service will be populated with any |
| * parameters that were passed. |
| * |
| * (See {@link ui.router.util.type:UrlMatcher UrlMatcher} `UrlMatcher`} for |
| * more details on acceptable patterns ) |
| * |
| * examples: |
| * <pre>url: "/home" |
| * url: "/users/:userid" |
| * url: "/books/{bookid:[a-zA-Z_-]}" |
| * url: "/books/{categoryid:int}" |
| * url: "/books/{publishername:string}/{categoryid:int}" |
| * url: "/messages?before&after" |
| * url: "/messages?{before:date}&{after:date}" |
| * url: "/messages/:mailboxid?{before:date}&{after:date}" |
| * </pre> |
| * |
| * @param {object=} stateConfig.views |
| * <a id='views'></a> |
| * an optional map<string, object> which defined multiple views, or targets views |
| * manually/explicitly. |
| * |
| * Examples: |
| * |
| * Targets three named `ui-view`s in the parent state's template |
| * <pre>views: { |
| * header: { |
| * controller: "headerCtrl", |
| * templateUrl: "header.html" |
| * }, body: { |
| * controller: "bodyCtrl", |
| * templateUrl: "body.html" |
| * }, footer: { |
| * controller: "footCtrl", |
| * templateUrl: "footer.html" |
| * } |
| * }</pre> |
| * |
| * Targets named `ui-view="header"` from grandparent state 'top''s template, and named `ui-view="body" from parent state's template. |
| * <pre>views: { |
| * 'header@top': { |
| * controller: "msgHeaderCtrl", |
| * templateUrl: "msgHeader.html" |
| * }, 'body': { |
| * controller: "messagesCtrl", |
| * templateUrl: "messages.html" |
| * } |
| * }</pre> |
| * |
| * @param {boolean=} [stateConfig.abstract=false] |
| * <a id='abstract'></a> |
| * An abstract state will never be directly activated, |
| * but can provide inherited properties to its common children states. |
| * <pre>abstract: true</pre> |
| * |
| * @param {function=} stateConfig.onEnter |
| * <a id='onEnter'></a> |
| * |
| * Callback function for when a state is entered. Good way |
| * to trigger an action or dispatch an event, such as opening a dialog. |
| * If minifying your scripts, make sure to explictly annotate this function, |
| * because it won't be automatically annotated by your build tools. |
| * |
| * <pre>onEnter: function(MyService, $stateParams) { |
| * MyService.foo($stateParams.myParam); |
| * }</pre> |
| * |
| * @param {function=} stateConfig.onExit |
| * <a id='onExit'></a> |
| * |
| * Callback function for when a state is exited. Good way to |
| * trigger an action or dispatch an event, such as opening a dialog. |
| * If minifying your scripts, make sure to explictly annotate this function, |
| * because it won't be automatically annotated by your build tools. |
| * |
| * <pre>onExit: function(MyService, $stateParams) { |
| * MyService.cleanup($stateParams.myParam); |
| * }</pre> |
| * |
| * @param {boolean=} [stateConfig.reloadOnSearch=true] |
| * <a id='reloadOnSearch'></a> |
| * |
| * If `false`, will not retrigger the same state |
| * just because a search/query parameter has changed (via $location.search() or $location.hash()). |
| * Useful for when you'd like to modify $location.search() without triggering a reload. |
| * <pre>reloadOnSearch: false</pre> |
| * |
| * @param {object=} stateConfig.data |
| * <a id='data'></a> |
| * |
| * Arbitrary data object, useful for custom configuration. The parent state's `data` is |
| * prototypally inherited. In other words, adding a data property to a state adds it to |
| * the entire subtree via prototypal inheritance. |
| * |
| * <pre>data: { |
| * requiredRole: 'foo' |
| * } </pre> |
| * |
| * @param {object=} stateConfig.params |
| * <a id='params'></a> |
| * |
| * A map which optionally configures parameters declared in the `url`, or |
| * defines additional non-url parameters. For each parameter being |
| * configured, add a configuration object keyed to the name of the parameter. |
| * |
| * Each parameter configuration object may contain the following properties: |
| * |
| * - ** value ** - {object|function=}: specifies the default value for this |
| * parameter. This implicitly sets this parameter as optional. |
| * |
| * When UI-Router routes to a state and no value is |
| * specified for this parameter in the URL or transition, the |
| * default value will be used instead. If `value` is a function, |
| * it will be injected and invoked, and the return value used. |
| * |
| * *Note*: `undefined` is treated as "no default value" while `null` |
| * is treated as "the default value is `null`". |
| * |
| * *Shorthand*: If you only need to configure the default value of the |
| * parameter, you may use a shorthand syntax. In the **`params`** |
| * map, instead mapping the param name to a full parameter configuration |
| * object, simply set map it to the default parameter value, e.g.: |
| * |
| * <pre>// define a parameter's default value |
| * params: { |
| * param1: { value: "defaultValue" } |
| * } |
| * // shorthand default values |
| * params: { |
| * param1: "defaultValue", |
| * param2: "param2Default" |
| * }</pre> |
| * |
| * - ** array ** - {boolean=}: *(default: false)* If true, the param value will be |
| * treated as an array of values. If you specified a Type, the value will be |
| * treated as an array of the specified Type. Note: query parameter values |
| * default to a special `"auto"` mode. |
| * |
| * For query parameters in `"auto"` mode, if multiple values for a single parameter |
| * are present in the URL (e.g.: `/foo?bar=1&bar=2&bar=3`) then the values |
| * are mapped to an array (e.g.: `{ foo: [ '1', '2', '3' ] }`). However, if |
| * only one value is present (e.g.: `/foo?bar=1`) then the value is treated as single |
| * value (e.g.: `{ foo: '1' }`). |
| * |
| * <pre>params: { |
| * param1: { array: true } |
| * }</pre> |
| * |
| * - ** squash ** - {bool|string=}: `squash` configures how a default parameter value is represented in the URL when |
| * the current parameter value is the same as the default value. If `squash` is not set, it uses the |
| * configured default squash policy. |
| * (See {@link ui.router.util.$urlMatcherFactory#methods_defaultSquashPolicy `defaultSquashPolicy()`}) |
| * |
| * There are three squash settings: |
| * |
| * - false: The parameter's default value is not squashed. It is encoded and included in the URL |
| * - true: The parameter's default value is omitted from the URL. If the parameter is preceeded and followed |
| * by slashes in the state's `url` declaration, then one of those slashes are omitted. |
| * This can allow for cleaner looking URLs. |
| * - `"<arbitrary string>"`: The parameter's default value is replaced with an arbitrary placeholder of your choice. |
| * |
| * <pre>params: { |
| * param1: { |
| * value: "defaultId", |
| * squash: true |
| * } } |
| * // squash "defaultValue" to "~" |
| * params: { |
| * param1: { |
| * value: "defaultValue", |
| * squash: "~" |
| * } } |
| * </pre> |
| * |
| * |
| * @example |
| * <pre> |
| * // Some state name examples |
| * |
| * // stateName can be a single top-level name (must be unique). |
| * $stateProvider.state("home", {}); |
| * |
| * // Or it can be a nested state name. This state is a child of the |
| * // above "home" state. |
| * $stateProvider.state("home.newest", {}); |
| * |
| * // Nest states as deeply as needed. |
| * $stateProvider.state("home.newest.abc.xyz.inception", {}); |
| * |
| * // state() returns $stateProvider, so you can chain state declarations. |
| * $stateProvider |
| * .state("home", {}) |
| * .state("about", {}) |
| * .state("contacts", {}); |
| * </pre> |
| * |
| */ |
| this.state = state; |
| function state(name, definition) { |
| /*jshint validthis: true */ |
| if (isObject(name)) definition = name; |
| else definition.name = name; |
| registerState(definition); |
| return this; |
| } |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.state.$state |
| * |
| * @requires $rootScope |
| * @requires $q |
| * @requires ui.router.state.$view |
| * @requires $injector |
| * @requires ui.router.util.$resolve |
| * @requires ui.router.state.$stateParams |
| * @requires ui.router.router.$urlRouter |
| * |
| * @property {object} params A param object, e.g. {sectionId: section.id)}, that |
| * you'd like to test against the current active state. |
| * @property {object} current A reference to the state's config object. However |
| * you passed it in. Useful for accessing custom data. |
| * @property {object} transition Currently pending transition. A promise that'll |
| * resolve or reject. |
| * |
| * @description |
| * `$state` service is responsible for representing states as well as transitioning |
| * between them. It also provides interfaces to ask for current state or even states |
| * you're coming from. |
| */ |
| this.$get = $get; |
| $get.$inject = ['$rootScope', '$q', '$view', '$injector', '$resolve', '$stateParams', '$urlRouter', '$location', '$urlMatcherFactory']; |
| function $get( $rootScope, $q, $view, $injector, $resolve, $stateParams, $urlRouter, $location, $urlMatcherFactory) { |
| |
| var TransitionSuperseded = $q.reject(new Error('transition superseded')); |
| var TransitionPrevented = $q.reject(new Error('transition prevented')); |
| var TransitionAborted = $q.reject(new Error('transition aborted')); |
| var TransitionFailed = $q.reject(new Error('transition failed')); |
| |
| // Handles the case where a state which is the target of a transition is not found, and the user |
| // can optionally retry or defer the transition |
| function handleRedirect(redirect, state, params, options) { |
| /** |
| * @ngdoc event |
| * @name ui.router.state.$state#$stateNotFound |
| * @eventOf ui.router.state.$state |
| * @eventType broadcast on root scope |
| * @description |
| * Fired when a requested state **cannot be found** using the provided state name during transition. |
| * The event is broadcast allowing any handlers a single chance to deal with the error (usually by |
| * lazy-loading the unfound state). A special `unfoundState` object is passed to the listener handler, |
| * you can see its three properties in the example. You can use `event.preventDefault()` to abort the |
| * transition and the promise returned from `go` will be rejected with a `'transition aborted'` value. |
| * |
| * @param {Object} event Event object. |
| * @param {Object} unfoundState Unfound State information. Contains: `to, toParams, options` properties. |
| * @param {State} fromState Current state object. |
| * @param {Object} fromParams Current state params. |
| * |
| * @example |
| * |
| * <pre> |
| * // somewhere, assume lazy.state has not been defined |
| * $state.go("lazy.state", {a:1, b:2}, {inherit:false}); |
| * |
| * // somewhere else |
| * $scope.$on('$stateNotFound', |
| * function(event, unfoundState, fromState, fromParams){ |
| * console.log(unfoundState.to); // "lazy.state" |
| * console.log(unfoundState.toParams); // {a:1, b:2} |
| * console.log(unfoundState.options); // {inherit:false} + default options |
| * }) |
| * </pre> |
| */ |
| var evt = $rootScope.$broadcast('$stateNotFound', redirect, state, params); |
| |
| if (evt.defaultPrevented) { |
| $urlRouter.update(); |
| return TransitionAborted; |
| } |
| |
| if (!evt.retry) { |
| return null; |
| } |
| |
| // Allow the handler to return a promise to defer state lookup retry |
| if (options.$retry) { |
| $urlRouter.update(); |
| return TransitionFailed; |
| } |
| var retryTransition = $state.transition = $q.when(evt.retry); |
| |
| retryTransition.then(function() { |
| if (retryTransition !== $state.transition) return TransitionSuperseded; |
| redirect.options.$retry = true; |
| return $state.transitionTo(redirect.to, redirect.toParams, redirect.options); |
| }, function() { |
| return TransitionAborted; |
| }); |
| $urlRouter.update(); |
| |
| return retryTransition; |
| } |
| |
| root.locals = { resolve: null, globals: { $stateParams: {} } }; |
| |
| $state = { |
| params: {}, |
| current: root.self, |
| $current: root, |
| transition: null |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#reload |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * A method that force reloads the current state. All resolves are re-resolved, |
| * controllers reinstantiated, and events re-fired. |
| * |
| * @example |
| * <pre> |
| * var app angular.module('app', ['ui.router']); |
| * |
| * app.controller('ctrl', function ($scope, $state) { |
| * $scope.reload = function(){ |
| * $state.reload(); |
| * } |
| * }); |
| * </pre> |
| * |
| * `reload()` is just an alias for: |
| * <pre> |
| * $state.transitionTo($state.current, $stateParams, { |
| * reload: true, inherit: false, notify: true |
| * }); |
| * </pre> |
| * |
| * @param {string=|object=} state - A state name or a state object, which is the root of the resolves to be re-resolved. |
| * @example |
| * <pre> |
| * //assuming app application consists of 3 states: 'contacts', 'contacts.detail', 'contacts.detail.item' |
| * //and current state is 'contacts.detail.item' |
| * var app angular.module('app', ['ui.router']); |
| * |
| * app.controller('ctrl', function ($scope, $state) { |
| * $scope.reload = function(){ |
| * //will reload 'contact.detail' and 'contact.detail.item' states |
| * $state.reload('contact.detail'); |
| * } |
| * }); |
| * </pre> |
| * |
| * `reload()` is just an alias for: |
| * <pre> |
| * $state.transitionTo($state.current, $stateParams, { |
| * reload: true, inherit: false, notify: true |
| * }); |
| * </pre> |
| |
| * @returns {promise} A promise representing the state of the new transition. See |
| * {@link ui.router.state.$state#methods_go $state.go}. |
| */ |
| $state.reload = function reload(state) { |
| return $state.transitionTo($state.current, $stateParams, { reload: state || true, inherit: false, notify: true}); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#go |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * Convenience method for transitioning to a new state. `$state.go` calls |
| * `$state.transitionTo` internally but automatically sets options to |
| * `{ location: true, inherit: true, relative: $state.$current, notify: true }`. |
| * This allows you to easily use an absolute or relative to path and specify |
| * only the parameters you'd like to update (while letting unspecified parameters |
| * inherit from the currently active ancestor states). |
| * |
| * @example |
| * <pre> |
| * var app = angular.module('app', ['ui.router']); |
| * |
| * app.controller('ctrl', function ($scope, $state) { |
| * $scope.changeState = function () { |
| * $state.go('contact.detail'); |
| * }; |
| * }); |
| * </pre> |
| * <img src='../ngdoc_assets/StateGoExamples.png'/> |
| * |
| * @param {string} to Absolute state name or relative state path. Some examples: |
| * |
| * - `$state.go('contact.detail')` - will go to the `contact.detail` state |
| * - `$state.go('^')` - will go to a parent state |
| * - `$state.go('^.sibling')` - will go to a sibling state |
| * - `$state.go('.child.grandchild')` - will go to grandchild state |
| * |
| * @param {object=} params A map of the parameters that will be sent to the state, |
| * will populate $stateParams. Any parameters that are not specified will be inherited from currently |
| * defined parameters. This allows, for example, going to a sibling state that shares parameters |
| * specified in a parent state. Parameter inheritance only works between common ancestor states, I.e. |
| * transitioning to a sibling will get you the parameters for all parents, transitioning to a child |
| * will get you all current parameters, etc. |
| * @param {object=} options Options object. The options are: |
| * |
| * - **`location`** - {boolean=true|string=} - If `true` will update the url in the location bar, if `false` |
| * will not. If string, must be `"replace"`, which will update url and also replace last history record. |
| * - **`inherit`** - {boolean=true}, If `true` will inherit url parameters from current url. |
| * - **`relative`** - {object=$state.$current}, When transitioning with relative path (e.g '^'), |
| * defines which state to be relative from. |
| * - **`notify`** - {boolean=true}, If `true` will broadcast $stateChangeStart and $stateChangeSuccess events. |
| * - **`reload`** (v0.2.5) - {boolean=false}, If `true` will force transition even if the state or params |
| * have not changed, aka a reload of the same state. It differs from reloadOnSearch because you'd |
| * use this when you want to force a reload when *everything* is the same, including search params. |
| * |
| * @returns {promise} A promise representing the state of the new transition. |
| * |
| * Possible success values: |
| * |
| * - $state.current |
| * |
| * <br/>Possible rejection values: |
| * |
| * - 'transition superseded' - when a newer transition has been started after this one |
| * - 'transition prevented' - when `event.preventDefault()` has been called in a `$stateChangeStart` listener |
| * - 'transition aborted' - when `event.preventDefault()` has been called in a `$stateNotFound` listener or |
| * when a `$stateNotFound` `event.retry` promise errors. |
| * - 'transition failed' - when a state has been unsuccessfully found after 2 tries. |
| * - *resolve error* - when an error has occurred with a `resolve` |
| * |
| */ |
| $state.go = function go(to, params, options) { |
| return $state.transitionTo(to, params, extend({ inherit: true, relative: $state.$current }, options)); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#transitionTo |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * Low-level method for transitioning to a new state. {@link ui.router.state.$state#methods_go $state.go} |
| * uses `transitionTo` internally. `$state.go` is recommended in most situations. |
| * |
| * @example |
| * <pre> |
| * var app = angular.module('app', ['ui.router']); |
| * |
| * app.controller('ctrl', function ($scope, $state) { |
| * $scope.changeState = function () { |
| * $state.transitionTo('contact.detail'); |
| * }; |
| * }); |
| * </pre> |
| * |
| * @param {string} to State name. |
| * @param {object=} toParams A map of the parameters that will be sent to the state, |
| * will populate $stateParams. |
| * @param {object=} options Options object. The options are: |
| * |
| * - **`location`** - {boolean=true|string=} - If `true` will update the url in the location bar, if `false` |
| * will not. If string, must be `"replace"`, which will update url and also replace last history record. |
| * - **`inherit`** - {boolean=false}, If `true` will inherit url parameters from current url. |
| * - **`relative`** - {object=}, When transitioning with relative path (e.g '^'), |
| * defines which state to be relative from. |
| * - **`notify`** - {boolean=true}, If `true` will broadcast $stateChangeStart and $stateChangeSuccess events. |
| * - **`reload`** (v0.2.5) - {boolean=false|string=|object=}, If `true` will force transition even if the state or params |
| * have not changed, aka a reload of the same state. It differs from reloadOnSearch because you'd |
| * use this when you want to force a reload when *everything* is the same, including search params. |
| * if String, then will reload the state with the name given in reload, and any children. |
| * if Object, then a stateObj is expected, will reload the state found in stateObj, and any children. |
| * |
| * @returns {promise} A promise representing the state of the new transition. See |
| * {@link ui.router.state.$state#methods_go $state.go}. |
| */ |
| $state.transitionTo = function transitionTo(to, toParams, options) { |
| toParams = toParams || {}; |
| options = extend({ |
| location: true, inherit: false, relative: null, notify: true, reload: false, $retry: false |
| }, options || {}); |
| |
| var from = $state.$current, fromParams = $state.params, fromPath = from.path; |
| var evt, toState = findState(to, options.relative); |
| |
| // Store the hash param for later (since it will be stripped out by various methods) |
| var hash = toParams['#']; |
| |
| if (!isDefined(toState)) { |
| var redirect = { to: to, toParams: toParams, options: options }; |
| var redirectResult = handleRedirect(redirect, from.self, fromParams, options); |
| |
| if (redirectResult) { |
| return redirectResult; |
| } |
| |
| // Always retry once if the $stateNotFound was not prevented |
| // (handles either redirect changed or state lazy-definition) |
| to = redirect.to; |
| toParams = redirect.toParams; |
| options = redirect.options; |
| toState = findState(to, options.relative); |
| |
| if (!isDefined(toState)) { |
| if (!options.relative) throw new Error("No such state '" + to + "'"); |
| throw new Error("Could not resolve '" + to + "' from state '" + options.relative + "'"); |
| } |
| } |
| if (toState[abstractKey]) throw new Error("Cannot transition to abstract state '" + to + "'"); |
| if (options.inherit) toParams = inheritParams($stateParams, toParams || {}, $state.$current, toState); |
| if (!toState.params.$$validates(toParams)) return TransitionFailed; |
| |
| toParams = toState.params.$$values(toParams); |
| to = toState; |
| |
| var toPath = to.path; |
| |
| // Starting from the root of the path, keep all levels that haven't changed |
| var keep = 0, state = toPath[keep], locals = root.locals, toLocals = []; |
| |
| if (!options.reload) { |
| while (state && state === fromPath[keep] && state.ownParams.$$equals(toParams, fromParams)) { |
| locals = toLocals[keep] = state.locals; |
| keep++; |
| state = toPath[keep]; |
| } |
| } else if (isString(options.reload) || isObject(options.reload)) { |
| if (isObject(options.reload) && !options.reload.name) { |
| throw new Error('Invalid reload state object'); |
| } |
| |
| var reloadState = options.reload === true ? fromPath[0] : findState(options.reload); |
| if (options.reload && !reloadState) { |
| throw new Error("No such reload state '" + (isString(options.reload) ? options.reload : options.reload.name) + "'"); |
| } |
| |
| while (state && state === fromPath[keep] && state !== reloadState) { |
| locals = toLocals[keep] = state.locals; |
| keep++; |
| state = toPath[keep]; |
| } |
| } |
| |
| // If we're going to the same state and all locals are kept, we've got nothing to do. |
| // But clear 'transition', as we still want to cancel any other pending transitions. |
| // TODO: We may not want to bump 'transition' if we're called from a location change |
| // that we've initiated ourselves, because we might accidentally abort a legitimate |
| // transition initiated from code? |
| if (shouldSkipReload(to, toParams, from, fromParams, locals, options)) { |
| if (hash) toParams['#'] = hash; |
| $state.params = toParams; |
| copy($state.params, $stateParams); |
| if (options.location && to.navigable && to.navigable.url) { |
| $urlRouter.push(to.navigable.url, toParams, { |
| $$avoidResync: true, replace: options.location === 'replace' |
| }); |
| $urlRouter.update(true); |
| } |
| $state.transition = null; |
| return $q.when($state.current); |
| } |
| |
| // Filter parameters before we pass them to event handlers etc. |
| toParams = filterByKeys(to.params.$$keys(), toParams || {}); |
| |
| // Broadcast start event and cancel the transition if requested |
| if (options.notify) { |
| /** |
| * @ngdoc event |
| * @name ui.router.state.$state#$stateChangeStart |
| * @eventOf ui.router.state.$state |
| * @eventType broadcast on root scope |
| * @description |
| * Fired when the state transition **begins**. You can use `event.preventDefault()` |
| * to prevent the transition from happening and then the transition promise will be |
| * rejected with a `'transition prevented'` value. |
| * |
| * @param {Object} event Event object. |
| * @param {State} toState The state being transitioned to. |
| * @param {Object} toParams The params supplied to the `toState`. |
| * @param {State} fromState The current state, pre-transition. |
| * @param {Object} fromParams The params supplied to the `fromState`. |
| * |
| * @example |
| * |
| * <pre> |
| * $rootScope.$on('$stateChangeStart', |
| * function(event, toState, toParams, fromState, fromParams){ |
| * event.preventDefault(); |
| * // transitionTo() promise will be rejected with |
| * // a 'transition prevented' error |
| * }) |
| * </pre> |
| */ |
| if ($rootScope.$broadcast('$stateChangeStart', to.self, toParams, from.self, fromParams).defaultPrevented) { |
| $rootScope.$broadcast('$stateChangeCancel', to.self, toParams, from.self, fromParams); |
| $urlRouter.update(); |
| return TransitionPrevented; |
| } |
| } |
| |
| // Resolve locals for the remaining states, but don't update any global state just |
| // yet -- if anything fails to resolve the current state needs to remain untouched. |
| // We also set up an inheritance chain for the locals here. This allows the view directive |
| // to quickly look up the correct definition for each view in the current state. Even |
| // though we create the locals object itself outside resolveState(), it is initially |
| // empty and gets filled asynchronously. We need to keep track of the promise for the |
| // (fully resolved) current locals, and pass this down the chain. |
| var resolved = $q.when(locals); |
| |
| for (var l = keep; l < toPath.length; l++, state = toPath[l]) { |
| locals = toLocals[l] = inherit(locals); |
| resolved = resolveState(state, toParams, state === to, resolved, locals, options); |
| } |
| |
| // Once everything is resolved, we are ready to perform the actual transition |
| // and return a promise for the new state. We also keep track of what the |
| // current promise is, so that we can detect overlapping transitions and |
| // keep only the outcome of the last transition. |
| var transition = $state.transition = resolved.then(function () { |
| var l, entering, exiting; |
| |
| if ($state.transition !== transition) return TransitionSuperseded; |
| |
| // Exit 'from' states not kept |
| for (l = fromPath.length - 1; l >= keep; l--) { |
| exiting = fromPath[l]; |
| if (exiting.self.onExit) { |
| $injector.invoke(exiting.self.onExit, exiting.self, exiting.locals.globals); |
| } |
| exiting.locals = null; |
| } |
| |
| // Enter 'to' states not kept |
| for (l = keep; l < toPath.length; l++) { |
| entering = toPath[l]; |
| entering.locals = toLocals[l]; |
| if (entering.self.onEnter) { |
| $injector.invoke(entering.self.onEnter, entering.self, entering.locals.globals); |
| } |
| } |
| |
| // Re-add the saved hash before we start returning things |
| if (hash) toParams['#'] = hash; |
| |
| // Run it again, to catch any transitions in callbacks |
| if ($state.transition !== transition) return TransitionSuperseded; |
| |
| // Update globals in $state |
| $state.$current = to; |
| $state.current = to.self; |
| $state.params = toParams; |
| copy($state.params, $stateParams); |
| $state.transition = null; |
| |
| if (options.location && to.navigable) { |
| $urlRouter.push(to.navigable.url, to.navigable.locals.globals.$stateParams, { |
| $$avoidResync: true, replace: options.location === 'replace' |
| }); |
| } |
| |
| if (options.notify) { |
| /** |
| * @ngdoc event |
| * @name ui.router.state.$state#$stateChangeSuccess |
| * @eventOf ui.router.state.$state |
| * @eventType broadcast on root scope |
| * @description |
| * Fired once the state transition is **complete**. |
| * |
| * @param {Object} event Event object. |
| * @param {State} toState The state being transitioned to. |
| * @param {Object} toParams The params supplied to the `toState`. |
| * @param {State} fromState The current state, pre-transition. |
| * @param {Object} fromParams The params supplied to the `fromState`. |
| */ |
| $rootScope.$broadcast('$stateChangeSuccess', to.self, toParams, from.self, fromParams); |
| } |
| $urlRouter.update(true); |
| |
| return $state.current; |
| }, function (error) { |
| if ($state.transition !== transition) return TransitionSuperseded; |
| |
| $state.transition = null; |
| /** |
| * @ngdoc event |
| * @name ui.router.state.$state#$stateChangeError |
| * @eventOf ui.router.state.$state |
| * @eventType broadcast on root scope |
| * @description |
| * Fired when an **error occurs** during transition. It's important to note that if you |
| * have any errors in your resolve functions (javascript errors, non-existent services, etc) |
| * they will not throw traditionally. You must listen for this $stateChangeError event to |
| * catch **ALL** errors. |
| * |
| * @param {Object} event Event object. |
| * @param {State} toState The state being transitioned to. |
| * @param {Object} toParams The params supplied to the `toState`. |
| * @param {State} fromState The current state, pre-transition. |
| * @param {Object} fromParams The params supplied to the `fromState`. |
| * @param {Error} error The resolve error object. |
| */ |
| evt = $rootScope.$broadcast('$stateChangeError', to.self, toParams, from.self, fromParams, error); |
| |
| if (!evt.defaultPrevented) { |
| $urlRouter.update(); |
| } |
| |
| return $q.reject(error); |
| }); |
| |
| return transition; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#is |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * Similar to {@link ui.router.state.$state#methods_includes $state.includes}, |
| * but only checks for the full state name. If params is supplied then it will be |
| * tested for strict equality against the current active params object, so all params |
| * must match with none missing and no extras. |
| * |
| * @example |
| * <pre> |
| * $state.$current.name = 'contacts.details.item'; |
| * |
| * // absolute name |
| * $state.is('contact.details.item'); // returns true |
| * $state.is(contactDetailItemStateObject); // returns true |
| * |
| * // relative name (. and ^), typically from a template |
| * // E.g. from the 'contacts.details' template |
| * <div ng-class="{highlighted: $state.is('.item')}">Item</div> |
| * </pre> |
| * |
| * @param {string|object} stateOrName The state name (absolute or relative) or state object you'd like to check. |
| * @param {object=} params A param object, e.g. `{sectionId: section.id}`, that you'd like |
| * to test against the current active state. |
| * @param {object=} options An options object. The options are: |
| * |
| * - **`relative`** - {string|object} - If `stateOrName` is a relative state name and `options.relative` is set, .is will |
| * test relative to `options.relative` state (or name). |
| * |
| * @returns {boolean} Returns true if it is the state. |
| */ |
| $state.is = function is(stateOrName, params, options) { |
| options = extend({ relative: $state.$current }, options || {}); |
| var state = findState(stateOrName, options.relative); |
| |
| if (!isDefined(state)) { return undefined; } |
| if ($state.$current !== state) { return false; } |
| return params ? equalForKeys(state.params.$$values(params), $stateParams) : true; |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#includes |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * A method to determine if the current active state is equal to or is the child of the |
| * state stateName. If any params are passed then they will be tested for a match as well. |
| * Not all the parameters need to be passed, just the ones you'd like to test for equality. |
| * |
| * @example |
| * Partial and relative names |
| * <pre> |
| * $state.$current.name = 'contacts.details.item'; |
| * |
| * // Using partial names |
| * $state.includes("contacts"); // returns true |
| * $state.includes("contacts.details"); // returns true |
| * $state.includes("contacts.details.item"); // returns true |
| * $state.includes("contacts.list"); // returns false |
| * $state.includes("about"); // returns false |
| * |
| * // Using relative names (. and ^), typically from a template |
| * // E.g. from the 'contacts.details' template |
| * <div ng-class="{highlighted: $state.includes('.item')}">Item</div> |
| * </pre> |
| * |
| * Basic globbing patterns |
| * <pre> |
| * $state.$current.name = 'contacts.details.item.url'; |
| * |
| * $state.includes("*.details.*.*"); // returns true |
| * $state.includes("*.details.**"); // returns true |
| * $state.includes("**.item.**"); // returns true |
| * $state.includes("*.details.item.url"); // returns true |
| * $state.includes("*.details.*.url"); // returns true |
| * $state.includes("*.details.*"); // returns false |
| * $state.includes("item.**"); // returns false |
| * </pre> |
| * |
| * @param {string} stateOrName A partial name, relative name, or glob pattern |
| * to be searched for within the current state name. |
| * @param {object=} params A param object, e.g. `{sectionId: section.id}`, |
| * that you'd like to test against the current active state. |
| * @param {object=} options An options object. The options are: |
| * |
| * - **`relative`** - {string|object=} - If `stateOrName` is a relative state reference and `options.relative` is set, |
| * .includes will test relative to `options.relative` state (or name). |
| * |
| * @returns {boolean} Returns true if it does include the state |
| */ |
| $state.includes = function includes(stateOrName, params, options) { |
| options = extend({ relative: $state.$current }, options || {}); |
| if (isString(stateOrName) && isGlob(stateOrName)) { |
| if (!doesStateMatchGlob(stateOrName)) { |
| return false; |
| } |
| stateOrName = $state.$current.name; |
| } |
| |
| var state = findState(stateOrName, options.relative); |
| if (!isDefined(state)) { return undefined; } |
| if (!isDefined($state.$current.includes[state.name])) { return false; } |
| return params ? equalForKeys(state.params.$$values(params), $stateParams, objectKeys(params)) : true; |
| }; |
| |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#href |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * A url generation method that returns the compiled url for the given state populated with the given params. |
| * |
| * @example |
| * <pre> |
| * expect($state.href("about.person", { person: "bob" })).toEqual("/about/bob"); |
| * </pre> |
| * |
| * @param {string|object} stateOrName The state name or state object you'd like to generate a url from. |
| * @param {object=} params An object of parameter values to fill the state's required parameters. |
| * @param {object=} options Options object. The options are: |
| * |
| * - **`lossy`** - {boolean=true} - If true, and if there is no url associated with the state provided in the |
| * first parameter, then the constructed href url will be built from the first navigable ancestor (aka |
| * ancestor with a valid url). |
| * - **`inherit`** - {boolean=true}, If `true` will inherit url parameters from current url. |
| * - **`relative`** - {object=$state.$current}, When transitioning with relative path (e.g '^'), |
| * defines which state to be relative from. |
| * - **`absolute`** - {boolean=false}, If true will generate an absolute url, e.g. "http://www.example.com/fullurl". |
| * |
| * @returns {string} compiled state url |
| */ |
| $state.href = function href(stateOrName, params, options) { |
| options = extend({ |
| lossy: true, |
| inherit: true, |
| absolute: false, |
| relative: $state.$current |
| }, options || {}); |
| |
| var state = findState(stateOrName, options.relative); |
| |
| if (!isDefined(state)) return null; |
| if (options.inherit) params = inheritParams($stateParams, params || {}, $state.$current, state); |
| |
| var nav = (state && options.lossy) ? state.navigable : state; |
| |
| if (!nav || nav.url === undefined || nav.url === null) { |
| return null; |
| } |
| return $urlRouter.href(nav.url, filterByKeys(state.params.$$keys().concat('#'), params || {}), { |
| absolute: options.absolute |
| }); |
| }; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$state#get |
| * @methodOf ui.router.state.$state |
| * |
| * @description |
| * Returns the state configuration object for any specific state or all states. |
| * |
| * @param {string|object=} stateOrName (absolute or relative) If provided, will only get the config for |
| * the requested state. If not provided, returns an array of ALL state configs. |
| * @param {string|object=} context When stateOrName is a relative state reference, the state will be retrieved relative to context. |
| * @returns {Object|Array} State configuration object or array of all objects. |
| */ |
| $state.get = function (stateOrName, context) { |
| if (arguments.length === 0) return map(objectKeys(states), function(name) { return states[name].self; }); |
| var state = findState(stateOrName, context || $state.$current); |
| return (state && state.self) ? state.self : null; |
| }; |
| |
| function resolveState(state, params, paramsAreFiltered, inherited, dst, options) { |
| // Make a restricted $stateParams with only the parameters that apply to this state if |
| // necessary. In addition to being available to the controller and onEnter/onExit callbacks, |
| // we also need $stateParams to be available for any $injector calls we make during the |
| // dependency resolution process. |
| var $stateParams = (paramsAreFiltered) ? params : filterByKeys(state.params.$$keys(), params); |
| var locals = { $stateParams: $stateParams }; |
| |
| // Resolve 'global' dependencies for the state, i.e. those not specific to a view. |
| // We're also including $stateParams in this; that way the parameters are restricted |
| // to the set that should be visible to the state, and are independent of when we update |
| // the global $state and $stateParams values. |
| dst.resolve = $resolve.resolve(state.resolve, locals, dst.resolve, state); |
| var promises = [dst.resolve.then(function (globals) { |
| dst.globals = globals; |
| })]; |
| if (inherited) promises.push(inherited); |
| |
| function resolveViews() { |
| var viewsPromises = []; |
| |
| // Resolve template and dependencies for all views. |
| forEach(state.views, function (view, name) { |
| var injectables = (view.resolve && view.resolve !== state.resolve ? view.resolve : {}); |
| injectables.$template = [ function () { |
| return $view.load(name, { view: view, locals: dst.globals, params: $stateParams, notify: options.notify }) || ''; |
| }]; |
| |
| viewsPromises.push($resolve.resolve(injectables, dst.globals, dst.resolve, state).then(function (result) { |
| // References to the controller (only instantiated at link time) |
| if (isFunction(view.controllerProvider) || isArray(view.controllerProvider)) { |
| var injectLocals = angular.extend({}, injectables, dst.globals); |
| result.$$controller = $injector.invoke(view.controllerProvider, null, injectLocals); |
| } else { |
| result.$$controller = view.controller; |
| } |
| // Provide access to the state itself for internal use |
| result.$$state = state; |
| result.$$controllerAs = view.controllerAs; |
| dst[name] = result; |
| })); |
| }); |
| |
| return $q.all(viewsPromises).then(function(){ |
| return dst.globals; |
| }); |
| } |
| |
| // Wait for all the promises and then return the activation object |
| return $q.all(promises).then(resolveViews).then(function (values) { |
| return dst; |
| }); |
| } |
| |
| return $state; |
| } |
| |
| function shouldSkipReload(to, toParams, from, fromParams, locals, options) { |
| // Return true if there are no differences in non-search (path/object) params, false if there are differences |
| function nonSearchParamsEqual(fromAndToState, fromParams, toParams) { |
| // Identify whether all the parameters that differ between `fromParams` and `toParams` were search params. |
| function notSearchParam(key) { |
| return fromAndToState.params[key].location != "search"; |
| } |
| var nonQueryParamKeys = fromAndToState.params.$$keys().filter(notSearchParam); |
| var nonQueryParams = pick.apply({}, [fromAndToState.params].concat(nonQueryParamKeys)); |
| var nonQueryParamSet = new $$UMFP.ParamSet(nonQueryParams); |
| return nonQueryParamSet.$$equals(fromParams, toParams); |
| } |
| |
| // If reload was not explicitly requested |
| // and we're transitioning to the same state we're already in |
| // and the locals didn't change |
| // or they changed in a way that doesn't merit reloading |
| // (reloadOnParams:false, or reloadOnSearch.false and only search params changed) |
| // Then return true. |
| if (!options.reload && to === from && |
| (locals === from.locals || (to.self.reloadOnSearch === false && nonSearchParamsEqual(from, fromParams, toParams)))) { |
| return true; |
| } |
| } |
| } |
| |
| angular.module('ui.router.state') |
| .value('$stateParams', {}) |
| .provider('$state', $StateProvider); |
| |
| |
| $ViewProvider.$inject = []; |
| function $ViewProvider() { |
| |
| this.$get = $get; |
| /** |
| * @ngdoc object |
| * @name ui.router.state.$view |
| * |
| * @requires ui.router.util.$templateFactory |
| * @requires $rootScope |
| * |
| * @description |
| * |
| */ |
| $get.$inject = ['$rootScope', '$templateFactory']; |
| function $get( $rootScope, $templateFactory) { |
| return { |
| // $view.load('full.viewName', { template: ..., controller: ..., resolve: ..., async: false, params: ... }) |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$view#load |
| * @methodOf ui.router.state.$view |
| * |
| * @description |
| * |
| * @param {string} name name |
| * @param {object} options option object. |
| */ |
| load: function load(name, options) { |
| var result, defaults = { |
| template: null, controller: null, view: null, locals: null, notify: true, async: true, params: {} |
| }; |
| options = extend(defaults, options); |
| |
| if (options.view) { |
| result = $templateFactory.fromConfig(options.view, options.params, options.locals); |
| } |
| if (result && options.notify) { |
| /** |
| * @ngdoc event |
| * @name ui.router.state.$state#$viewContentLoading |
| * @eventOf ui.router.state.$view |
| * @eventType broadcast on root scope |
| * @description |
| * |
| * Fired once the view **begins loading**, *before* the DOM is rendered. |
| * |
| * @param {Object} event Event object. |
| * @param {Object} viewConfig The view config properties (template, controller, etc). |
| * |
| * @example |
| * |
| * <pre> |
| * $scope.$on('$viewContentLoading', |
| * function(event, viewConfig){ |
| * // Access to all the view config properties. |
| * // and one special property 'targetView' |
| * // viewConfig.targetView |
| * }); |
| * </pre> |
| */ |
| $rootScope.$broadcast('$viewContentLoading', options); |
| } |
| return result; |
| } |
| }; |
| } |
| } |
| |
| angular.module('ui.router.state').provider('$view', $ViewProvider); |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.state.$uiViewScrollProvider |
| * |
| * @description |
| * Provider that returns the {@link ui.router.state.$uiViewScroll} service function. |
| */ |
| function $ViewScrollProvider() { |
| |
| var useAnchorScroll = false; |
| |
| /** |
| * @ngdoc function |
| * @name ui.router.state.$uiViewScrollProvider#useAnchorScroll |
| * @methodOf ui.router.state.$uiViewScrollProvider |
| * |
| * @description |
| * Reverts back to using the core [`$anchorScroll`](http://docs.angularjs.org/api/ng.$anchorScroll) service for |
| * scrolling based on the url anchor. |
| */ |
| this.useAnchorScroll = function () { |
| useAnchorScroll = true; |
| }; |
| |
| /** |
| * @ngdoc object |
| * @name ui.router.state.$uiViewScroll |
| * |
| * @requires $anchorScroll |
| * @requires $timeout |
| * |
| * @description |
| * When called with a jqLite element, it scrolls the element into view (after a |
| * `$timeout` so the DOM has time to refresh). |
| * |
| * If you prefer to rely on `$anchorScroll` to scroll the view to the anchor, |
| * this can be enabled by calling {@link ui.router.state.$uiViewScrollProvider#methods_useAnchorScroll `$uiViewScrollProvider.useAnchorScroll()`}. |
| */ |
| this.$get = ['$anchorScroll', '$timeout', function ($anchorScroll, $timeout) { |
| if (useAnchorScroll) { |
| return $anchorScroll; |
| } |
| |
| return function ($element) { |
| return $timeout(function () { |
| $element[0].scrollIntoView(); |
| }, 0, false); |
| }; |
| }]; |
| } |
| |
| angular.module('ui.router.state').provider('$uiViewScroll', $ViewScrollProvider); |
| |
| /** |
| * @ngdoc directive |
| * @name ui.router.state.directive:ui-view |
| * |
| * @requires ui.router.state.$state |
| * @requires $compile |
| * @requires $controller |
| * @requires $injector |
| * @requires ui.router.state.$uiViewScroll |
| * @requires $document |
| * |
| * @restrict ECA |
| * |
| * @description |
| * The ui-view directive tells $state where to place your templates. |
| * |
| * @param {string=} name A view name. The name should be unique amongst the other views in the |
| * same state. You can have views of the same name that live in different states. |
| * |
| * @param {string=} autoscroll It allows you to set the scroll behavior of the browser window |
| * when a view is populated. By default, $anchorScroll is overridden by ui-router's custom scroll |
| * service, {@link ui.router.state.$uiViewScroll}. This custom service let's you |
| * scroll ui-view elements into view when they are populated during a state activation. |
| * |
| * *Note: To revert back to old [`$anchorScroll`](http://docs.angularjs.org/api/ng.$anchorScroll) |
| * functionality, call `$uiViewScrollProvider.useAnchorScroll()`.* |
| * |
| * @param {string=} onload Expression to evaluate whenever the view updates. |
| * |
| * @example |
| * A view can be unnamed or named. |
| * <pre> |
| * <!-- Unnamed --> |
| * <div ui-view></div> |
| * |
| * <!-- Named --> |
| * <div ui-view="viewName"></div> |
| * </pre> |
| * |
| * You can only have one unnamed view within any template (or root html). If you are only using a |
| * single view and it is unnamed then you can populate it like so: |
| * <pre> |
| * <div ui-view></div> |
| * $stateProvider.state("home", { |
| * template: "<h1>HELLO!</h1>" |
| * }) |
| * </pre> |
| * |
| * The above is a convenient shortcut equivalent to specifying your view explicitly with the {@link ui.router.state.$stateProvider#views `views`} |
| * config property, by name, in this case an empty name: |
| * <pre> |
| * $stateProvider.state("home", { |
| * views: { |
| * "": { |
| * template: "<h1>HELLO!</h1>" |
| * } |
| * } |
| * }) |
| * </pre> |
| * |
| * But typically you'll only use the views property if you name your view or have more than one view |
| * in the same template. There's not really a compelling reason to name a view if its the only one, |
| * but you could if you wanted, like so: |
| * <pre> |
| * <div ui-view="main"></div> |
| * </pre> |
| * <pre> |
| * $stateProvider.state("home", { |
| * views: { |
| * "main": { |
| * template: "<h1>HELLO!</h1>" |
| * } |
| * } |
| * }) |
| * </pre> |
| * |
| * Really though, you'll use views to set up multiple views: |
| * <pre> |
| * <div ui-view></div> |
| * <div ui-view="chart"></div> |
| * <div ui-view="data"></div> |
| * </pre> |
| * |
| * <pre> |
| * $stateProvider.state("home", { |
| * views: { |
| * "": { |
| * template: "<h1>HELLO!</h1>" |
| * }, |
| * "chart": { |
| * template: "<chart_thing/>" |
| * }, |
| * "data": { |
| * template: "<data_thing/>" |
| * } |
| * } |
| * }) |
| * </pre> |
| * |
| * Examples for `autoscroll`: |
| * |
| * <pre> |
| * <!-- If autoscroll present with no expression, |
| * then scroll ui-view into view --> |
| * <ui-view autoscroll/> |
| * |
| * <!-- If autoscroll present with valid expression, |
| * then scroll ui-view into view if expression evaluates to true --> |
| * <ui-view autoscroll='true'/> |
| * <ui-view autoscroll='false'/> |
| * <ui-view autoscroll='scopeVariable'/> |
| * </pre> |
| */ |
| $ViewDirective.$inject = ['$state', '$injector', '$uiViewScroll', '$interpolate']; |
| function $ViewDirective( $state, $injector, $uiViewScroll, $interpolate) { |
| |
| function getService() { |
| return ($injector.has) ? function(service) { |
| return $injector.has(service) ? $injector.get(service) : null; |
| } : function(service) { |
| try { |
| return $injector.get(service); |
| } catch (e) { |
| return null; |
| } |
| }; |
| } |
| |
| var service = getService(), |
| $animator = service('$animator'), |
| $animate = service('$animate'); |
| |
| // Returns a set of DOM manipulation functions based on which Angular version |
| // it should use |
| function getRenderer(attrs, scope) { |
| var statics = function() { |
| return { |
| enter: function (element, target, cb) { target.after(element); cb(); }, |
| leave: function (element, cb) { element.remove(); cb(); } |
| }; |
| }; |
| |
| if ($animate) { |
| return { |
| enter: function(element, target, cb) { |
| var promise = $animate.enter(element, null, target, cb); |
| if (promise && promise.then) promise.then(cb); |
| }, |
| leave: function(element, cb) { |
| var promise = $animate.leave(element, cb); |
| if (promise && promise.then) promise.then(cb); |
| } |
| }; |
| } |
| |
| if ($animator) { |
| var animate = $animator && $animator(scope, attrs); |
| |
| return { |
| enter: function(element, target, cb) {animate.enter(element, null, target); cb(); }, |
| leave: function(element, cb) { animate.leave(element); cb(); } |
| }; |
| } |
| |
| return statics(); |
| } |
| |
| var directive = { |
| restrict: 'ECA', |
| terminal: true, |
| priority: 400, |
| transclude: 'element', |
| compile: function (tElement, tAttrs, $transclude) { |
| return function (scope, $element, attrs) { |
| var previousEl, currentEl, currentScope, latestLocals, |
| onloadExp = attrs.onload || '', |
| autoScrollExp = attrs.autoscroll, |
| renderer = getRenderer(attrs, scope); |
| |
| scope.$on('$stateChangeSuccess', function() { |
| updateView(false); |
| }); |
| scope.$on('$viewContentLoading', function() { |
| updateView(false); |
| }); |
| |
| updateView(true); |
| |
| function cleanupLastView() { |
| if (previousEl) { |
| previousEl.remove(); |
| previousEl = null; |
| } |
| |
| if (currentScope) { |
| currentScope.$destroy(); |
| currentScope = null; |
| } |
| |
| if (currentEl) { |
| renderer.leave(currentEl, function() { |
| previousEl = null; |
| }); |
| |
| previousEl = currentEl; |
| currentEl = null; |
| } |
| } |
| |
| function updateView(firstTime) { |
| var newScope, |
| name = getUiViewName(scope, attrs, $element, $interpolate), |
| previousLocals = name && $state.$current && $state.$current.locals[name]; |
| |
| if (!firstTime && previousLocals === latestLocals) return; // nothing to do |
| newScope = scope.$new(); |
| latestLocals = $state.$current.locals[name]; |
| |
| var clone = $transclude(newScope, function(clone) { |
| renderer.enter(clone, $element, function onUiViewEnter() { |
| if(currentScope) { |
| currentScope.$emit('$viewContentAnimationEnded'); |
| } |
| |
| if (angular.isDefined(autoScrollExp) && !autoScrollExp || scope.$eval(autoScrollExp)) { |
| $uiViewScroll(clone); |
| } |
| }); |
| cleanupLastView(); |
| }); |
| |
| currentEl = clone; |
| currentScope = newScope; |
| /** |
| * @ngdoc event |
| * @name ui.router.state.directive:ui-view#$viewContentLoaded |
| * @eventOf ui.router.state.directive:ui-view |
| * @eventType emits on ui-view directive scope |
| * @description * |
| * Fired once the view is **loaded**, *after* the DOM is rendered. |
| * |
| * @param {Object} event Event object. |
| */ |
| currentScope.$emit('$viewContentLoaded'); |
| currentScope.$eval(onloadExp); |
| } |
| }; |
| } |
| }; |
| |
| return directive; |
| } |
| |
| $ViewDirectiveFill.$inject = ['$compile', '$controller', '$state', '$interpolate']; |
| function $ViewDirectiveFill ( $compile, $controller, $state, $interpolate) { |
| return { |
| restrict: 'ECA', |
| priority: -400, |
| compile: function (tElement) { |
| var initial = tElement.html(); |
| return function (scope, $element, attrs) { |
| var current = $state.$current, |
| name = getUiViewName(scope, attrs, $element, $interpolate), |
| locals = current && current.locals[name]; |
| |
| if (! locals) { |
| return; |
| } |
| |
| $element.data('$uiView', { name: name, state: locals.$$state }); |
| $element.html(locals.$template ? locals.$template : initial); |
| |
| var link = $compile($element.contents()); |
| |
| if (locals.$$controller) { |
| locals.$scope = scope; |
| locals.$element = $element; |
| var controller = $controller(locals.$$controller, locals); |
| if (locals.$$controllerAs) { |
| scope[locals.$$controllerAs] = controller; |
| } |
| $element.data('$ngControllerController', controller); |
| $element.children().data('$ngControllerController', controller); |
| } |
| |
| link(scope); |
| }; |
| } |
| }; |
| } |
| |
| /** |
| * Shared ui-view code for both directives: |
| * Given scope, element, and its attributes, return the view's name |
| */ |
| function getUiViewName(scope, attrs, element, $interpolate) { |
| var name = $interpolate(attrs.uiView || attrs.name || '')(scope); |
| var inherited = element.inheritedData('$uiView'); |
| return name.indexOf('@') >= 0 ? name : (name + '@' + (inherited ? inherited.state.name : '')); |
| } |
| |
| angular.module('ui.router.state').directive('uiView', $ViewDirective); |
| angular.module('ui.router.state').directive('uiView', $ViewDirectiveFill); |
| |
| function parseStateRef(ref, current) { |
| var preparsed = ref.match(/^\s*({[^}]*})\s*$/), parsed; |
| if (preparsed) ref = current + '(' + preparsed[1] + ')'; |
| parsed = ref.replace(/\n/g, " ").match(/^([^(]+?)\s*(\((.*)\))?$/); |
| if (!parsed || parsed.length !== 4) throw new Error("Invalid state ref '" + ref + "'"); |
| return { state: parsed[1], paramExpr: parsed[3] || null }; |
| } |
| |
| function stateContext(el) { |
| var stateData = el.parent().inheritedData('$uiView'); |
| |
| if (stateData && stateData.state && stateData.state.name) { |
| return stateData.state; |
| } |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name ui.router.state.directive:ui-sref |
| * |
| * @requires ui.router.state.$state |
| * @requires $timeout |
| * |
| * @restrict A |
| * |
| * @description |
| * A directive that binds a link (`<a>` tag) to a state. If the state has an associated |
| * URL, the directive will automatically generate & update the `href` attribute via |
| * the {@link ui.router.state.$state#methods_href $state.href()} method. Clicking |
| * the link will trigger a state transition with optional parameters. |
| * |
| * Also middle-clicking, right-clicking, and ctrl-clicking on the link will be |
| * handled natively by the browser. |
| * |
| * You can also use relative state paths within ui-sref, just like the relative |
| * paths passed to `$state.go()`. You just need to be aware that the path is relative |
| * to the state that the link lives in, in other words the state that loaded the |
| * template containing the link. |
| * |
| * You can specify options to pass to {@link ui.router.state.$state#go $state.go()} |
| * using the `ui-sref-opts` attribute. Options are restricted to `location`, `inherit`, |
| * and `reload`. |
| * |
| * @example |
| * Here's an example of how you'd use ui-sref and how it would compile. If you have the |
| * following template: |
| * <pre> |
| * <a ui-sref="home">Home</a> | <a ui-sref="about">About</a> | <a ui-sref="{page: 2}">Next page</a> |
| * |
| * <ul> |
| * <li ng-repeat="contact in contacts"> |
| * <a ui-sref="contacts.detail({ id: contact.id })">{{ contact.name }}</a> |
| * </li> |
| * </ul> |
| * </pre> |
| * |
| * Then the compiled html would be (assuming Html5Mode is off and current state is contacts): |
| * <pre> |
| * <a href="#/home" ui-sref="home">Home</a> | <a href="#/about" ui-sref="about">About</a> | <a href="#/contacts?page=2" ui-sref="{page: 2}">Next page</a> |
| * |
| * <ul> |
| * <li ng-repeat="contact in contacts"> |
| * <a href="#/contacts/1" ui-sref="contacts.detail({ id: contact.id })">Joe</a> |
| * </li> |
| * <li ng-repeat="contact in contacts"> |
| * <a href="#/contacts/2" ui-sref="contacts.detail({ id: contact.id })">Alice</a> |
| * </li> |
| * <li ng-repeat="contact in contacts"> |
| * <a href="#/contacts/3" ui-sref="contacts.detail({ id: contact.id })">Bob</a> |
| * </li> |
| * </ul> |
| * |
| * <a ui-sref="home" ui-sref-opts="{reload: true}">Home</a> |
| * </pre> |
| * |
| * @param {string} ui-sref 'stateName' can be any valid absolute or relative state |
| * @param {Object} ui-sref-opts options to pass to {@link ui.router.state.$state#go $state.go()} |
| */ |
| $StateRefDirective.$inject = ['$state', '$timeout']; |
| function $StateRefDirective($state, $timeout) { |
| var allowedOptions = ['location', 'inherit', 'reload', 'absolute']; |
| |
| return { |
| restrict: 'A', |
| require: ['?^uiSrefActive', '?^uiSrefActiveEq'], |
| link: function(scope, element, attrs, uiSrefActive) { |
| var ref = parseStateRef(attrs.uiSref, $state.current.name); |
| var params = null, url = null, base = stateContext(element) || $state.$current; |
| // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute. |
| var hrefKind = Object.prototype.toString.call(element.prop('href')) === '[object SVGAnimatedString]' ? |
| 'xlink:href' : 'href'; |
| var newHref = null, isAnchor = element.prop("tagName").toUpperCase() === "A"; |
| var isForm = element[0].nodeName === "FORM"; |
| var attr = isForm ? "action" : hrefKind, nav = true; |
| |
| var options = { relative: base, inherit: true }; |
| var optionsOverride = scope.$eval(attrs.uiSrefOpts) || {}; |
| |
| angular.forEach(allowedOptions, function(option) { |
| if (option in optionsOverride) { |
| options[option] = optionsOverride[option]; |
| } |
| }); |
| |
| var update = function(newVal) { |
| if (newVal) params = angular.copy(newVal); |
| if (!nav) return; |
| |
| newHref = $state.href(ref.state, params, options); |
| |
| var activeDirective = uiSrefActive[1] || uiSrefActive[0]; |
| if (activeDirective) { |
| activeDirective.$$addStateInfo(ref.state, params); |
| } |
| if (newHref === null) { |
| nav = false; |
| return false; |
| } |
| attrs.$set(attr, newHref); |
| }; |
| |
| if (ref.paramExpr) { |
| scope.$watch(ref.paramExpr, function(newVal, oldVal) { |
| if (newVal !== params) update(newVal); |
| }, true); |
| params = angular.copy(scope.$eval(ref.paramExpr)); |
| } |
| update(); |
| |
| if (isForm) return; |
| |
| element.bind("click", function(e) { |
| var button = e.which || e.button; |
| if ( !(button > 1 || e.ctrlKey || e.metaKey || e.shiftKey || element.attr('target')) ) { |
| // HACK: This is to allow ng-clicks to be processed before the transition is initiated: |
| var transition = $timeout(function() { |
| $state.go(ref.state, params, options); |
| }); |
| e.preventDefault(); |
| |
| // if the state has no URL, ignore one preventDefault from the <a> directive. |
| var ignorePreventDefaultCount = isAnchor && !newHref ? 1: 0; |
| e.preventDefault = function() { |
| if (ignorePreventDefaultCount-- <= 0) |
| $timeout.cancel(transition); |
| }; |
| } |
| }); |
| } |
| }; |
| } |
| |
| /** |
| * @ngdoc directive |
| * @name ui.router.state.directive:ui-sref-active |
| * |
| * @requires ui.router.state.$state |
| * @requires ui.router.state.$stateParams |
| * @requires $interpolate |
| * |
| * @restrict A |
| * |
| * @description |
| * A directive working alongside ui-sref to add classes to an element when the |
| * related ui-sref directive's state is active, and removing them when it is inactive. |
| * The primary use-case is to simplify the special appearance of navigation menus |
| * relying on `ui-sref`, by having the "active" state's menu button appear different, |
| * distinguishing it from the inactive menu items. |
| * |
| * ui-sref-active can live on the same element as ui-sref or on a parent element. The first |
| * ui-sref-active found at the same level or above the ui-sref will be used. |
| * |
| * Will activate when the ui-sref's target state or any child state is active. If you |
| * need to activate only when the ui-sref target state is active and *not* any of |
| * it's children, then you will use |
| * {@link ui.router.state.directive:ui-sref-active-eq ui-sref-active-eq} |
| * |
| * @example |
| * Given the following template: |
| * <pre> |
| * <ul> |
| * <li ui-sref-active="active" class="item"> |
| * <a href ui-sref="app.user({user: 'bilbobaggins'})">@bilbobaggins</a> |
| * </li> |
| * </ul> |
| * </pre> |
| * |
| * |
| * When the app state is "app.user" (or any children states), and contains the state parameter "user" with value "bilbobaggins", |
| * the resulting HTML will appear as (note the 'active' class): |
| * <pre> |
| * <ul> |
| * <li ui-sref-active="active" class="item active"> |
| * <a ui-sref="app.user({user: 'bilbobaggins'})" href="/users/bilbobaggins">@bilbobaggins</a> |
| * </li> |
| * </ul> |
| * </pre> |
| * |
| * The class name is interpolated **once** during the directives link time (any further changes to the |
| * interpolated value are ignored). |
| * |
| * Multiple classes may be specified in a space-separated format: |
| * <pre> |
| * <ul> |
| * <li ui-sref-active='class1 class2 class3'> |
| * <a ui-sref="app.user">link</a> |
| * </li> |
| * </ul> |
| * </pre> |
| */ |
| |
| /** |
| * @ngdoc directive |
| * @name ui.router.state.directive:ui-sref-active-eq |
| * |
| * @requires ui.router.state.$state |
| * @requires ui.router.state.$stateParams |
| * @requires $interpolate |
| * |
| * @restrict A |
| * |
| * @description |
| * The same as {@link ui.router.state.directive:ui-sref-active ui-sref-active} but will only activate |
| * when the exact target state used in the `ui-sref` is active; no child states. |
| * |
| */ |
| $StateRefActiveDirective.$inject = ['$state', '$stateParams', '$interpolate']; |
| function $StateRefActiveDirective($state, $stateParams, $interpolate) { |
| return { |
| restrict: "A", |
| controller: ['$scope', '$element', '$attrs', function ($scope, $element, $attrs) { |
| var states = [], activeClass; |
| |
| // There probably isn't much point in $observing this |
| // uiSrefActive and uiSrefActiveEq share the same directive object with some |
| // slight difference in logic routing |
| activeClass = $interpolate($attrs.uiSrefActiveEq || $attrs.uiSrefActive || '', false)($scope); |
| |
| // Allow uiSref to communicate with uiSrefActive[Equals] |
| this.$$addStateInfo = function (newState, newParams) { |
| var state = $state.get(newState, stateContext($element)); |
| |
| states.push({ |
| state: state || { name: newState }, |
| params: newParams |
| }); |
| |
| update(); |
| }; |
| |
| $scope.$on('$stateChangeSuccess', update); |
| |
| // Update route state |
| function update() { |
| if (anyMatch()) { |
| $element.addClass(activeClass); |
| } else { |
| $element.removeClass(activeClass); |
| } |
| } |
| |
| function anyMatch() { |
| for (var i = 0; i < states.length; i++) { |
| if (isMatch(states[i].state, states[i].params)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| function isMatch(state, params) { |
| if (typeof $attrs.uiSrefActiveEq !== 'undefined') { |
| return $state.is(state.name, params); |
| } else { |
| return $state.includes(state.name, params); |
| } |
| } |
| }] |
| }; |
| } |
| |
| angular.module('ui.router.state') |
| .directive('uiSref', $StateRefDirective) |
| .directive('uiSrefActive', $StateRefActiveDirective) |
| .directive('uiSrefActiveEq', $StateRefActiveDirective); |
| |
| /** |
| * @ngdoc filter |
| * @name ui.router.state.filter:isState |
| * |
| * @requires ui.router.state.$state |
| * |
| * @description |
| * Translates to {@link ui.router.state.$state#methods_is $state.is("stateName")}. |
| */ |
| $IsStateFilter.$inject = ['$state']; |
| function $IsStateFilter($state) { |
| var isFilter = function (state) { |
| return $state.is(state); |
| }; |
| isFilter.$stateful = true; |
| return isFilter; |
| } |
| |
| /** |
| * @ngdoc filter |
| * @name ui.router.state.filter:includedByState |
| * |
| * @requires ui.router.state.$state |
| * |
| * @description |
| * Translates to {@link ui.router.state.$state#methods_includes $state.includes('fullOrPartialStateName')}. |
| */ |
| $IncludedByStateFilter.$inject = ['$state']; |
| function $IncludedByStateFilter($state) { |
| var includesFilter = function (state) { |
| return $state.includes(state); |
| }; |
| includesFilter.$stateful = true; |
| return includesFilter; |
| } |
| |
| angular.module('ui.router.state') |
| .filter('isState', $IsStateFilter) |
| .filter('includedByState', $IncludedByStateFilter); |
| })(window, window.angular); |
| /** |
| * @license AngularJS v1.4.7 |
| * (c) 2010-2015 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| (function(window, angular, undefined) {'use strict'; |
| |
| var $resourceMinErr = angular.$$minErr('$resource'); |
| |
| // Helper functions and regex to lookup a dotted path on an object |
| // stopping at undefined/null. The path must be composed of ASCII |
| // identifiers (just like $parse) |
| var MEMBER_NAME_REGEX = /^(\.[a-zA-Z_$@][0-9a-zA-Z_$@]*)+$/; |
| |
| function isValidDottedPath(path) { |
| return (path != null && path !== '' && path !== 'hasOwnProperty' && |
| MEMBER_NAME_REGEX.test('.' + path)); |
| } |
| |
| function lookupDottedPath(obj, path) { |
| if (!isValidDottedPath(path)) { |
| throw $resourceMinErr('badmember', 'Dotted member path "@{0}" is invalid.', path); |
| } |
| var keys = path.split('.'); |
| for (var i = 0, ii = keys.length; i < ii && angular.isDefined(obj); i++) { |
| var key = keys[i]; |
| obj = (obj !== null) ? obj[key] : undefined; |
| } |
| return obj; |
| } |
| |
| /** |
| * Create a shallow copy of an object and clear other fields from the destination |
| */ |
| function shallowClearAndCopy(src, dst) { |
| dst = dst || {}; |
| |
| angular.forEach(dst, function(value, key) { |
| delete dst[key]; |
| }); |
| |
| for (var key in src) { |
| if (src.hasOwnProperty(key) && !(key.charAt(0) === '$' && key.charAt(1) === '$')) { |
| dst[key] = src[key]; |
| } |
| } |
| |
| return dst; |
| } |
| |
| /** |
| * @ngdoc module |
| * @name ngResource |
| * @description |
| * |
| * # ngResource |
| * |
| * The `ngResource` module provides interaction support with RESTful services |
| * via the $resource service. |
| * |
| * |
| * <div doc-module-components="ngResource"></div> |
| * |
| * See {@link ngResource.$resource `$resource`} for usage. |
| */ |
| |
| /** |
| * @ngdoc service |
| * @name $resource |
| * @requires $http |
| * |
| * @description |
| * A factory which creates a resource object that lets you interact with |
| * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources. |
| * |
| * The returned resource object has action methods which provide high-level behaviors without |
| * the need to interact with the low level {@link ng.$http $http} service. |
| * |
| * Requires the {@link ngResource `ngResource`} module to be installed. |
| * |
| * By default, trailing slashes will be stripped from the calculated URLs, |
| * which can pose problems with server backends that do not expect that |
| * behavior. This can be disabled by configuring the `$resourceProvider` like |
| * this: |
| * |
| * ```js |
| app.config(['$resourceProvider', function($resourceProvider) { |
| // Don't strip trailing slashes from calculated URLs |
| $resourceProvider.defaults.stripTrailingSlashes = false; |
| }]); |
| * ``` |
| * |
| * @param {string} url A parameterized URL template with parameters prefixed by `:` as in |
| * `/user/:username`. If you are using a URL with a port number (e.g. |
| * `http://example.com:8080/api`), it will be respected. |
| * |
| * If you are using a url with a suffix, just add the suffix, like this: |
| * `$resource('http://example.com/resource.json')` or `$resource('http://example.com/:id.json')` |
| * or even `$resource('http://example.com/resource/:resource_id.:format')` |
| * If the parameter before the suffix is empty, :resource_id in this case, then the `/.` will be |
| * collapsed down to a single `.`. If you need this sequence to appear and not collapse then you |
| * can escape it with `/\.`. |
| * |
| * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in |
| * `actions` methods. If any of the parameter value is a function, it will be executed every time |
| * when a param value needs to be obtained for a request (unless the param was overridden). |
| * |
| * Each key value in the parameter object is first bound to url template if present and then any |
| * excess keys are appended to the url search query after the `?`. |
| * |
| * Given a template `/path/:verb` and parameter `{verb:'greet', salutation:'Hello'}` results in |
| * URL `/path/greet?salutation=Hello`. |
| * |
| * If the parameter value is prefixed with `@` then the value for that parameter will be extracted |
| * from the corresponding property on the `data` object (provided when calling an action method). For |
| * example, if the `defaultParam` object is `{someParam: '@someProp'}` then the value of `someParam` |
| * will be `data.someProp`. |
| * |
| * @param {Object.<Object>=} actions Hash with declaration of custom actions that should extend |
| * the default set of resource actions. The declaration should be created in the format of {@link |
| * ng.$http#usage $http.config}: |
| * |
| * {action1: {method:?, params:?, isArray:?, headers:?, ...}, |
| * action2: {method:?, params:?, isArray:?, headers:?, ...}, |
| * ...} |
| * |
| * Where: |
| * |
| * - **`action`** – {string} – The name of action. This name becomes the name of the method on |
| * your resource object. |
| * - **`method`** – {string} – Case insensitive HTTP method (e.g. `GET`, `POST`, `PUT`, |
| * `DELETE`, `JSONP`, etc). |
| * - **`params`** – {Object=} – Optional set of pre-bound parameters for this action. If any of |
| * the parameter value is a function, it will be executed every time when a param value needs to |
| * be obtained for a request (unless the param was overridden). |
| * - **`url`** – {string} – action specific `url` override. The url templating is supported just |
| * like for the resource-level urls. |
| * - **`isArray`** – {boolean=} – If true then the returned object for this action is an array, |
| * see `returns` section. |
| * - **`transformRequest`** – |
| * `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` – |
| * transform function or an array of such functions. The transform function takes the http |
| * request body and headers and returns its transformed (typically serialized) version. |
| * By default, transformRequest will contain one function that checks if the request data is |
| * an object and serializes to using `angular.toJson`. To prevent this behavior, set |
| * `transformRequest` to an empty array: `transformRequest: []` |
| * - **`transformResponse`** – |
| * `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` – |
| * transform function or an array of such functions. The transform function takes the http |
| * response body and headers and returns its transformed (typically deserialized) version. |
| * By default, transformResponse will contain one function that checks if the response looks like |
| * a JSON string and deserializes it using `angular.fromJson`. To prevent this behavior, set |
| * `transformResponse` to an empty array: `transformResponse: []` |
| * - **`cache`** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the |
| * GET request, otherwise if a cache instance built with |
| * {@link ng.$cacheFactory $cacheFactory}, this cache will be used for |
| * caching. |
| * - **`timeout`** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise} that |
| * should abort the request when resolved. |
| * - **`withCredentials`** - `{boolean}` - whether to set the `withCredentials` flag on the |
| * XHR object. See |
| * [requests with credentials](https://developer.mozilla.org/en/http_access_control#section_5) |
| * for more information. |
| * - **`responseType`** - `{string}` - see |
| * [requestType](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType). |
| * - **`interceptor`** - `{Object=}` - The interceptor object has two optional methods - |
| * `response` and `responseError`. Both `response` and `responseError` interceptors get called |
| * with `http response` object. See {@link ng.$http $http interceptors}. |
| * |
| * @param {Object} options Hash with custom settings that should extend the |
| * default `$resourceProvider` behavior. The only supported option is |
| * |
| * Where: |
| * |
| * - **`stripTrailingSlashes`** – {boolean} – If true then the trailing |
| * slashes from any calculated URL will be stripped. (Defaults to true.) |
| * |
| * @returns {Object} A resource "class" object with methods for the default set of resource actions |
| * optionally extended with custom `actions`. The default set contains these actions: |
| * ```js |
| * { 'get': {method:'GET'}, |
| * 'save': {method:'POST'}, |
| * 'query': {method:'GET', isArray:true}, |
| * 'remove': {method:'DELETE'}, |
| * 'delete': {method:'DELETE'} }; |
| * ``` |
| * |
| * Calling these methods invoke an {@link ng.$http} with the specified http method, |
| * destination and parameters. When the data is returned from the server then the object is an |
| * instance of the resource class. The actions `save`, `remove` and `delete` are available on it |
| * as methods with the `$` prefix. This allows you to easily perform CRUD operations (create, |
| * read, update, delete) on server-side data like this: |
| * ```js |
| * var User = $resource('/user/:userId', {userId:'@id'}); |
| * var user = User.get({userId:123}, function() { |
| * user.abc = true; |
| * user.$save(); |
| * }); |
| * ``` |
| * |
| * It is important to realize that invoking a $resource object method immediately returns an |
| * empty reference (object or array depending on `isArray`). Once the data is returned from the |
| * server the existing reference is populated with the actual data. This is a useful trick since |
| * usually the resource is assigned to a model which is then rendered by the view. Having an empty |
| * object results in no rendering, once the data arrives from the server then the object is |
| * populated with the data and the view automatically re-renders itself showing the new data. This |
| * means that in most cases one never has to write a callback function for the action methods. |
| * |
| * The action methods on the class object or instance object can be invoked with the following |
| * parameters: |
| * |
| * - HTTP GET "class" actions: `Resource.action([parameters], [success], [error])` |
| * - non-GET "class" actions: `Resource.action([parameters], postData, [success], [error])` |
| * - non-GET instance actions: `instance.$action([parameters], [success], [error])` |
| * |
| * |
| * Success callback is called with (value, responseHeaders) arguments, where the value is |
| * the populated resource instance or collection object. The error callback is called |
| * with (httpResponse) argument. |
| * |
| * Class actions return empty instance (with additional properties below). |
| * Instance actions return promise of the action. |
| * |
| * The Resource instances and collection have these additional properties: |
| * |
| * - `$promise`: the {@link ng.$q promise} of the original server interaction that created this |
| * instance or collection. |
| * |
| * On success, the promise is resolved with the same resource instance or collection object, |
| * updated with data from server. This makes it easy to use in |
| * {@link ngRoute.$routeProvider resolve section of $routeProvider.when()} to defer view |
| * rendering until the resource(s) are loaded. |
| * |
| * On failure, the promise is resolved with the {@link ng.$http http response} object, without |
| * the `resource` property. |
| * |
| * If an interceptor object was provided, the promise will instead be resolved with the value |
| * returned by the interceptor. |
| * |
| * - `$resolved`: `true` after first server interaction is completed (either with success or |
| * rejection), `false` before that. Knowing if the Resource has been resolved is useful in |
| * data-binding. |
| * |
| * @example |
| * |
| * # Credit card resource |
| * |
| * ```js |
| // Define CreditCard class |
| var CreditCard = $resource('/user/:userId/card/:cardId', |
| {userId:123, cardId:'@id'}, { |
| charge: {method:'POST', params:{charge:true}} |
| }); |
| |
| // We can retrieve a collection from the server |
| var cards = CreditCard.query(function() { |
| // GET: /user/123/card |
| // server returns: [ {id:456, number:'1234', name:'Smith'} ]; |
| |
| var card = cards[0]; |
| // each item is an instance of CreditCard |
| expect(card instanceof CreditCard).toEqual(true); |
| card.name = "J. Smith"; |
| // non GET methods are mapped onto the instances |
| card.$save(); |
| // POST: /user/123/card/456 {id:456, number:'1234', name:'J. Smith'} |
| // server returns: {id:456, number:'1234', name: 'J. Smith'}; |
| |
| // our custom method is mapped as well. |
| card.$charge({amount:9.99}); |
| // POST: /user/123/card/456?amount=9.99&charge=true {id:456, number:'1234', name:'J. Smith'} |
| }); |
| |
| // we can create an instance as well |
| var newCard = new CreditCard({number:'0123'}); |
| newCard.name = "Mike Smith"; |
| newCard.$save(); |
| // POST: /user/123/card {number:'0123', name:'Mike Smith'} |
| // server returns: {id:789, number:'0123', name: 'Mike Smith'}; |
| expect(newCard.id).toEqual(789); |
| * ``` |
| * |
| * The object returned from this function execution is a resource "class" which has "static" method |
| * for each action in the definition. |
| * |
| * Calling these methods invoke `$http` on the `url` template with the given `method`, `params` and |
| * `headers`. |
| * When the data is returned from the server then the object is an instance of the resource type and |
| * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD |
| * operations (create, read, update, delete) on server-side data. |
| |
| ```js |
| var User = $resource('/user/:userId', {userId:'@id'}); |
| User.get({userId:123}, function(user) { |
| user.abc = true; |
| user.$save(); |
| }); |
| ``` |
| * |
| * It's worth noting that the success callback for `get`, `query` and other methods gets passed |
| * in the response that came from the server as well as $http header getter function, so one |
| * could rewrite the above example and get access to http headers as: |
| * |
| ```js |
| var User = $resource('/user/:userId', {userId:'@id'}); |
| User.get({userId:123}, function(u, getResponseHeaders){ |
| u.abc = true; |
| u.$save(function(u, putResponseHeaders) { |
| //u => saved user object |
| //putResponseHeaders => $http header getter |
| }); |
| }); |
| ``` |
| * |
| * You can also access the raw `$http` promise via the `$promise` property on the object returned |
| * |
| ``` |
| var User = $resource('/user/:userId', {userId:'@id'}); |
| User.get({userId:123}) |
| .$promise.then(function(user) { |
| $scope.user = user; |
| }); |
| ``` |
| |
| * # Creating a custom 'PUT' request |
| * In this example we create a custom method on our resource to make a PUT request |
| * ```js |
| * var app = angular.module('app', ['ngResource', 'ngRoute']); |
| * |
| * // Some APIs expect a PUT request in the format URL/object/ID |
| * // Here we are creating an 'update' method |
| * app.factory('Notes', ['$resource', function($resource) { |
| * return $resource('/notes/:id', null, |
| * { |
| * 'update': { method:'PUT' } |
| * }); |
| * }]); |
| * |
| * // In our controller we get the ID from the URL using ngRoute and $routeParams |
| * // We pass in $routeParams and our Notes factory along with $scope |
| * app.controller('NotesCtrl', ['$scope', '$routeParams', 'Notes', |
| function($scope, $routeParams, Notes) { |
| * // First get a note object from the factory |
| * var note = Notes.get({ id:$routeParams.id }); |
| * $id = note.id; |
| * |
| * // Now call update passing in the ID first then the object you are updating |
| * Notes.update({ id:$id }, note); |
| * |
| * // This will PUT /notes/ID with the note object in the request payload |
| * }]); |
| * ``` |
| */ |
| angular.module('ngResource', ['ng']). |
| provider('$resource', function() { |
| var PROTOCOL_AND_DOMAIN_REGEX = /^https?:\/\/[^\/]*/; |
| var provider = this; |
| |
| this.defaults = { |
| // Strip slashes by default |
| stripTrailingSlashes: true, |
| |
| // Default actions configuration |
| actions: { |
| 'get': {method: 'GET'}, |
| 'save': {method: 'POST'}, |
| 'query': {method: 'GET', isArray: true}, |
| 'remove': {method: 'DELETE'}, |
| 'delete': {method: 'DELETE'} |
| } |
| }; |
| |
| this.$get = ['$http', '$q', function($http, $q) { |
| |
| var noop = angular.noop, |
| forEach = angular.forEach, |
| extend = angular.extend, |
| copy = angular.copy, |
| isFunction = angular.isFunction; |
| |
| /** |
| * We need our custom method because encodeURIComponent is too aggressive and doesn't follow |
| * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set |
| * (pchar) allowed in path segments: |
| * segment = *pchar |
| * pchar = unreserved / pct-encoded / sub-delims / ":" / "@" |
| * pct-encoded = "%" HEXDIG HEXDIG |
| * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" |
| * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" |
| * / "*" / "+" / "," / ";" / "=" |
| */ |
| function encodeUriSegment(val) { |
| return encodeUriQuery(val, true). |
| replace(/%26/gi, '&'). |
| replace(/%3D/gi, '='). |
| replace(/%2B/gi, '+'); |
| } |
| |
| |
| /** |
| * This method is intended for encoding *key* or *value* parts of query component. We need a |
| * custom method because encodeURIComponent is too aggressive and encodes stuff that doesn't |
| * have to be encoded per http://tools.ietf.org/html/rfc3986: |
| * query = *( pchar / "/" / "?" ) |
| * pchar = unreserved / pct-encoded / sub-delims / ":" / "@" |
| * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" |
| * pct-encoded = "%" HEXDIG HEXDIG |
| * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" |
| * / "*" / "+" / "," / ";" / "=" |
| */ |
| function encodeUriQuery(val, pctEncodeSpaces) { |
| return encodeURIComponent(val). |
| replace(/%40/gi, '@'). |
| replace(/%3A/gi, ':'). |
| replace(/%24/g, '$'). |
| replace(/%2C/gi, ','). |
| replace(/%20/g, (pctEncodeSpaces ? '%20' : '+')); |
| } |
| |
| function Route(template, defaults) { |
| this.template = template; |
| this.defaults = extend({}, provider.defaults, defaults); |
| this.urlParams = {}; |
| } |
| |
| Route.prototype = { |
| setUrlParams: function(config, params, actionUrl) { |
| var self = this, |
| url = actionUrl || self.template, |
| val, |
| encodedVal, |
| protocolAndDomain = ''; |
| |
| var urlParams = self.urlParams = {}; |
| forEach(url.split(/\W/), function(param) { |
| if (param === 'hasOwnProperty') { |
| throw $resourceMinErr('badname', "hasOwnProperty is not a valid parameter name."); |
| } |
| if (!(new RegExp("^\\d+$").test(param)) && param && |
| (new RegExp("(^|[^\\\\]):" + param + "(\\W|$)").test(url))) { |
| urlParams[param] = true; |
| } |
| }); |
| url = url.replace(/\\:/g, ':'); |
| url = url.replace(PROTOCOL_AND_DOMAIN_REGEX, function(match) { |
| protocolAndDomain = match; |
| return ''; |
| }); |
| |
| params = params || {}; |
| forEach(self.urlParams, function(_, urlParam) { |
| val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam]; |
| if (angular.isDefined(val) && val !== null) { |
| encodedVal = encodeUriSegment(val); |
| url = url.replace(new RegExp(":" + urlParam + "(\\W|$)", "g"), function(match, p1) { |
| return encodedVal + p1; |
| }); |
| } else { |
| url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W|$)", "g"), function(match, |
| leadingSlashes, tail) { |
| if (tail.charAt(0) == '/') { |
| return tail; |
| } else { |
| return leadingSlashes + tail; |
| } |
| }); |
| } |
| }); |
| |
| // strip trailing slashes and set the url (unless this behavior is specifically disabled) |
| if (self.defaults.stripTrailingSlashes) { |
| url = url.replace(/\/+$/, '') || '/'; |
| } |
| |
| // then replace collapse `/.` if found in the last URL path segment before the query |
| // E.g. `http://url.com/id./format?q=x` becomes `http://url.com/id.format?q=x` |
| url = url.replace(/\/\.(?=\w+($|\?))/, '.'); |
| // replace escaped `/\.` with `/.` |
| config.url = protocolAndDomain + url.replace(/\/\\\./, '/.'); |
| |
| |
| // set params - delegate param encoding to $http |
| forEach(params, function(value, key) { |
| if (!self.urlParams[key]) { |
| config.params = config.params || {}; |
| config.params[key] = value; |
| } |
| }); |
| } |
| }; |
| |
| |
| function resourceFactory(url, paramDefaults, actions, options) { |
| var route = new Route(url, options); |
| |
| actions = extend({}, provider.defaults.actions, actions); |
| |
| function extractParams(data, actionParams) { |
| var ids = {}; |
| actionParams = extend({}, paramDefaults, actionParams); |
| forEach(actionParams, function(value, key) { |
| if (isFunction(value)) { value = value(); } |
| ids[key] = value && value.charAt && value.charAt(0) == '@' ? |
| lookupDottedPath(data, value.substr(1)) : value; |
| }); |
| return ids; |
| } |
| |
| function defaultResponseInterceptor(response) { |
| return response.resource; |
| } |
| |
| function Resource(value) { |
| shallowClearAndCopy(value || {}, this); |
| } |
| |
| Resource.prototype.toJSON = function() { |
| var data = extend({}, this); |
| delete data.$promise; |
| delete data.$resolved; |
| return data; |
| }; |
| |
| forEach(actions, function(action, name) { |
| var hasBody = /^(POST|PUT|PATCH)$/i.test(action.method); |
| |
| Resource[name] = function(a1, a2, a3, a4) { |
| var params = {}, data, success, error; |
| |
| /* jshint -W086 */ /* (purposefully fall through case statements) */ |
| switch (arguments.length) { |
| case 4: |
| error = a4; |
| success = a3; |
| //fallthrough |
| case 3: |
| case 2: |
| if (isFunction(a2)) { |
| if (isFunction(a1)) { |
| success = a1; |
| error = a2; |
| break; |
| } |
| |
| success = a2; |
| error = a3; |
| //fallthrough |
| } else { |
| params = a1; |
| data = a2; |
| success = a3; |
| break; |
| } |
| case 1: |
| if (isFunction(a1)) success = a1; |
| else if (hasBody) data = a1; |
| else params = a1; |
| break; |
| case 0: break; |
| default: |
| throw $resourceMinErr('badargs', |
| "Expected up to 4 arguments [params, data, success, error], got {0} arguments", |
| arguments.length); |
| } |
| /* jshint +W086 */ /* (purposefully fall through case statements) */ |
| |
| var isInstanceCall = this instanceof Resource; |
| var value = isInstanceCall ? data : (action.isArray ? [] : new Resource(data)); |
| var httpConfig = {}; |
| var responseInterceptor = action.interceptor && action.interceptor.response || |
| defaultResponseInterceptor; |
| var responseErrorInterceptor = action.interceptor && action.interceptor.responseError || |
| undefined; |
| |
| forEach(action, function(value, key) { |
| if (key != 'params' && key != 'isArray' && key != 'interceptor') { |
| httpConfig[key] = copy(value); |
| } |
| }); |
| |
| if (hasBody) httpConfig.data = data; |
| route.setUrlParams(httpConfig, |
| extend({}, extractParams(data, action.params || {}), params), |
| action.url); |
| |
| var promise = $http(httpConfig).then(function(response) { |
| var data = response.data, |
| promise = value.$promise; |
| |
| if (data) { |
| // Need to convert action.isArray to boolean in case it is undefined |
| // jshint -W018 |
| if (angular.isArray(data) !== (!!action.isArray)) { |
| throw $resourceMinErr('badcfg', |
| 'Error in resource configuration for action `{0}`. Expected response to ' + |
| 'contain an {1} but got an {2} (Request: {3} {4})', name, action.isArray ? 'array' : 'object', |
| angular.isArray(data) ? 'array' : 'object', httpConfig.method, httpConfig.url); |
| } |
| // jshint +W018 |
| if (action.isArray) { |
| value.length = 0; |
| forEach(data, function(item) { |
| if (typeof item === "object") { |
| value.push(new Resource(item)); |
| } else { |
| // Valid JSON values may be string literals, and these should not be converted |
| // into objects. These items will not have access to the Resource prototype |
| // methods, but unfortunately there |
| value.push(item); |
| } |
| }); |
| } else { |
| shallowClearAndCopy(data, value); |
| value.$promise = promise; |
| } |
| } |
| |
| value.$resolved = true; |
| |
| response.resource = value; |
| |
| return response; |
| }, function(response) { |
| value.$resolved = true; |
| |
| (error || noop)(response); |
| |
| return $q.reject(response); |
| }); |
| |
| promise = promise.then( |
| function(response) { |
| var value = responseInterceptor(response); |
| (success || noop)(value, response.headers); |
| return value; |
| }, |
| responseErrorInterceptor); |
| |
| if (!isInstanceCall) { |
| // we are creating instance / collection |
| // - set the initial promise |
| // - return the instance / collection |
| value.$promise = promise; |
| value.$resolved = false; |
| |
| return value; |
| } |
| |
| // instance call |
| return promise; |
| }; |
| |
| |
| Resource.prototype['$' + name] = function(params, success, error) { |
| if (isFunction(params)) { |
| error = success; success = params; params = {}; |
| } |
| var result = Resource[name].call(this, params, this, success, error); |
| return result.$promise || result; |
| }; |
| }); |
| |
| Resource.bind = function(additionalParamDefaults) { |
| return resourceFactory(url, extend({}, paramDefaults, additionalParamDefaults), actions); |
| }; |
| |
| return Resource; |
| } |
| |
| return resourceFactory; |
| }]; |
| }); |
| |
| |
| })(window, window.angular); |
| |
| /** |
| * @license |
| * lodash 3.10.1 (Custom Build) <https://lodash.com/> |
| * Build: `lodash modern exports="amd,commonjs,node" iife="angular.module('ngLodash', []).constant('lodash', null).config(function ($provide) { %output% $provide.constant('lodash', _);});" --output build/ng-lodash.js` |
| * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/> |
| * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> |
| * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| * Available under MIT license <https://lodash.com/license> |
| */ |
| angular.module('ngLodash', []).constant('lodash', null).config([ |
| '$provide', |
| function ($provide) { |
| /** Used as a safe reference for `undefined` in pre-ES5 environments. */ |
| var undefined; |
| /** Used as the semantic version number. */ |
| var VERSION = '3.10.1'; |
| /** Used to compose bitmasks for wrapper metadata. */ |
| var BIND_FLAG = 1, BIND_KEY_FLAG = 2, CURRY_BOUND_FLAG = 4, CURRY_FLAG = 8, CURRY_RIGHT_FLAG = 16, PARTIAL_FLAG = 32, PARTIAL_RIGHT_FLAG = 64, ARY_FLAG = 128, REARG_FLAG = 256; |
| /** Used as default options for `_.trunc`. */ |
| var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = '...'; |
| /** Used to detect when a function becomes hot. */ |
| var HOT_COUNT = 150, HOT_SPAN = 16; |
| /** Used as the size to enable large array optimizations. */ |
| var LARGE_ARRAY_SIZE = 200; |
| /** Used to indicate the type of lazy iteratees. */ |
| var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2; |
| /** Used as the `TypeError` message for "Functions" methods. */ |
| var FUNC_ERROR_TEXT = 'Expected a function'; |
| /** Used as the internal argument placeholder. */ |
| var PLACEHOLDER = '__lodash_placeholder__'; |
| /** `Object#toString` result references. */ |
| var argsTag = '[object Arguments]', arrayTag = '[object Array]', boolTag = '[object Boolean]', dateTag = '[object Date]', errorTag = '[object Error]', funcTag = '[object Function]', mapTag = '[object Map]', numberTag = '[object Number]', objectTag = '[object Object]', regexpTag = '[object RegExp]', setTag = '[object Set]', stringTag = '[object String]', weakMapTag = '[object WeakMap]'; |
| var arrayBufferTag = '[object ArrayBuffer]', float32Tag = '[object Float32Array]', float64Tag = '[object Float64Array]', int8Tag = '[object Int8Array]', int16Tag = '[object Int16Array]', int32Tag = '[object Int32Array]', uint8Tag = '[object Uint8Array]', uint8ClampedTag = '[object Uint8ClampedArray]', uint16Tag = '[object Uint16Array]', uint32Tag = '[object Uint32Array]'; |
| /** Used to match empty string literals in compiled template source. */ |
| var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; |
| /** Used to match HTML entities and HTML characters. */ |
| var reEscapedHtml = /&(?:amp|lt|gt|quot|#39|#96);/g, reUnescapedHtml = /[&<>"'`]/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source); |
| /** Used to match template delimiters. */ |
| var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g; |
| /** Used to match property names within property paths. */ |
| var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g; |
| /** |
| * Used to match `RegExp` [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns) |
| * and those outlined by [`EscapeRegExpPattern`](http://ecma-international.org/ecma-262/6.0/#sec-escaperegexppattern). |
| */ |
| var reRegExpChars = /^[:!,]|[\\^$.*+?()[\]{}|\/]|(^[0-9a-fA-Fnrtuvx])|([\n\r\u2028\u2029])/g, reHasRegExpChars = RegExp(reRegExpChars.source); |
| /** Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). */ |
| var reComboMark = /[\u0300-\u036f\ufe20-\ufe23]/g; |
| /** Used to match backslashes in property paths. */ |
| var reEscapeChar = /\\(\\)?/g; |
| /** Used to match [ES template delimiters](http://ecma-international.org/ecma-262/6.0/#sec-template-literal-lexical-components). */ |
| var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; |
| /** Used to match `RegExp` flags from their coerced string values. */ |
| var reFlags = /\w*$/; |
| /** Used to detect hexadecimal string values. */ |
| var reHasHexPrefix = /^0[xX]/; |
| /** Used to detect host constructors (Safari > 5). */ |
| var reIsHostCtor = /^\[object .+?Constructor\]$/; |
| /** Used to detect unsigned integer values. */ |
| var reIsUint = /^\d+$/; |
| /** Used to match latin-1 supplementary letters (excluding mathematical operators). */ |
| var reLatin1 = /[\xc0-\xd6\xd8-\xde\xdf-\xf6\xf8-\xff]/g; |
| /** Used to ensure capturing order of template delimiters. */ |
| var reNoMatch = /($^)/; |
| /** Used to match unescaped characters in compiled string literals. */ |
| var reUnescapedString = /['\n\r\u2028\u2029\\]/g; |
| /** Used to match words to create compound words. */ |
| var reWords = function () { |
| var upper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]', lower = '[a-z\\xdf-\\xf6\\xf8-\\xff]+'; |
| return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g'); |
| }(); |
| /** Used to assign default `context` object properties. */ |
| var contextProps = [ |
| 'Array', |
| 'ArrayBuffer', |
| 'Date', |
| 'Error', |
| 'Float32Array', |
| 'Float64Array', |
| 'Function', |
| 'Int8Array', |
| 'Int16Array', |
| 'Int32Array', |
| 'Math', |
| 'Number', |
| 'Object', |
| 'RegExp', |
| 'Set', |
| 'String', |
| '_', |
| 'clearTimeout', |
| 'isFinite', |
| 'parseFloat', |
| 'parseInt', |
| 'setTimeout', |
| 'TypeError', |
| 'Uint8Array', |
| 'Uint8ClampedArray', |
| 'Uint16Array', |
| 'Uint32Array', |
| 'WeakMap' |
| ]; |
| /** Used to make template sourceURLs easier to identify. */ |
| var templateCounter = -1; |
| /** Used to identify `toStringTag` values of typed arrays. */ |
| var typedArrayTags = {}; |
| typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true; |
| typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; |
| /** Used to identify `toStringTag` values supported by `_.clone`. */ |
| var cloneableTags = {}; |
| cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[stringTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; |
| cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[mapTag] = cloneableTags[setTag] = cloneableTags[weakMapTag] = false; |
| /** Used to map latin-1 supplementary letters to basic latin letters. */ |
| var deburredLetters = { |
| '\xc0': 'A', |
| '\xc1': 'A', |
| '\xc2': 'A', |
| '\xc3': 'A', |
| '\xc4': 'A', |
| '\xc5': 'A', |
| '\xe0': 'a', |
| '\xe1': 'a', |
| '\xe2': 'a', |
| '\xe3': 'a', |
| '\xe4': 'a', |
| '\xe5': 'a', |
| '\xc7': 'C', |
| '\xe7': 'c', |
| '\xd0': 'D', |
| '\xf0': 'd', |
| '\xc8': 'E', |
| '\xc9': 'E', |
| '\xca': 'E', |
| '\xcb': 'E', |
| '\xe8': 'e', |
| '\xe9': 'e', |
| '\xea': 'e', |
| '\xeb': 'e', |
| '\xcc': 'I', |
| '\xcd': 'I', |
| '\xce': 'I', |
| '\xcf': 'I', |
| '\xec': 'i', |
| '\xed': 'i', |
| '\xee': 'i', |
| '\xef': 'i', |
| '\xd1': 'N', |
| '\xf1': 'n', |
| '\xd2': 'O', |
| '\xd3': 'O', |
| '\xd4': 'O', |
| '\xd5': 'O', |
| '\xd6': 'O', |
| '\xd8': 'O', |
| '\xf2': 'o', |
| '\xf3': 'o', |
| '\xf4': 'o', |
| '\xf5': 'o', |
| '\xf6': 'o', |
| '\xf8': 'o', |
| '\xd9': 'U', |
| '\xda': 'U', |
| '\xdb': 'U', |
| '\xdc': 'U', |
| '\xf9': 'u', |
| '\xfa': 'u', |
| '\xfb': 'u', |
| '\xfc': 'u', |
| '\xdd': 'Y', |
| '\xfd': 'y', |
| '\xff': 'y', |
| '\xc6': 'Ae', |
| '\xe6': 'ae', |
| '\xde': 'Th', |
| '\xfe': 'th', |
| '\xdf': 'ss' |
| }; |
| /** Used to map characters to HTML entities. */ |
| var htmlEscapes = { |
| '&': '&', |
| '<': '<', |
| '>': '>', |
| '"': '"', |
| '\'': ''', |
| '`': '`' |
| }; |
| /** Used to map HTML entities to characters. */ |
| var htmlUnescapes = { |
| '&': '&', |
| '<': '<', |
| '>': '>', |
| '"': '"', |
| ''': '\'', |
| '`': '`' |
| }; |
| /** Used to determine if values are of the language type `Object`. */ |
| var objectTypes = { |
| 'function': true, |
| 'object': true |
| }; |
| /** Used to escape characters for inclusion in compiled regexes. */ |
| var regexpEscapes = { |
| '0': 'x30', |
| '1': 'x31', |
| '2': 'x32', |
| '3': 'x33', |
| '4': 'x34', |
| '5': 'x35', |
| '6': 'x36', |
| '7': 'x37', |
| '8': 'x38', |
| '9': 'x39', |
| 'A': 'x41', |
| 'B': 'x42', |
| 'C': 'x43', |
| 'D': 'x44', |
| 'E': 'x45', |
| 'F': 'x46', |
| 'a': 'x61', |
| 'b': 'x62', |
| 'c': 'x63', |
| 'd': 'x64', |
| 'e': 'x65', |
| 'f': 'x66', |
| 'n': 'x6e', |
| 'r': 'x72', |
| 't': 'x74', |
| 'u': 'x75', |
| 'v': 'x76', |
| 'x': 'x78' |
| }; |
| /** Used to escape characters for inclusion in compiled string literals. */ |
| var stringEscapes = { |
| '\\': '\\', |
| '\'': '\'', |
| '\n': 'n', |
| '\r': 'r', |
| '\u2028': 'u2028', |
| '\u2029': 'u2029' |
| }; |
| /** Detect free variable `exports`. */ |
| var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; |
| /** Detect free variable `module`. */ |
| var freeModule = objectTypes[typeof module] && module && !module.nodeType && module; |
| /** Detect free variable `global` from Node.js. */ |
| var freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global; |
| /** Detect free variable `self`. */ |
| var freeSelf = objectTypes[typeof self] && self && self.Object && self; |
| /** Detect free variable `window`. */ |
| var freeWindow = objectTypes[typeof window] && window && window.Object && window; |
| /** Detect the popular CommonJS extension `module.exports`. */ |
| var moduleExports = freeModule && freeModule.exports === freeExports && freeExports; |
| /** |
| * Used as a reference to the global object. |
| * |
| * The `this` value is used if it's the global object to avoid Greasemonkey's |
| * restricted `window` object, otherwise the `window` object is used. |
| */ |
| var root = freeGlobal || freeWindow !== (this && this.window) && freeWindow || freeSelf || this; |
| /*--------------------------------------------------------------------------*/ |
| /** |
| * The base implementation of `compareAscending` which compares values and |
| * sorts them in ascending order without guaranteeing a stable sort. |
| * |
| * @private |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {number} Returns the sort order indicator for `value`. |
| */ |
| function baseCompareAscending(value, other) { |
| if (value !== other) { |
| var valIsNull = value === null, valIsUndef = value === undefined, valIsReflexive = value === value; |
| var othIsNull = other === null, othIsUndef = other === undefined, othIsReflexive = other === other; |
| if (value > other && !othIsNull || !valIsReflexive || valIsNull && !othIsUndef && othIsReflexive || valIsUndef && othIsReflexive) { |
| return 1; |
| } |
| if (value < other && !valIsNull || !othIsReflexive || othIsNull && !valIsUndef && valIsReflexive || othIsUndef && valIsReflexive) { |
| return -1; |
| } |
| } |
| return 0; |
| } |
| /** |
| * The base implementation of `_.findIndex` and `_.findLastIndex` without |
| * support for callback shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to search. |
| * @param {Function} predicate The function invoked per iteration. |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {number} Returns the index of the matched value, else `-1`. |
| */ |
| function baseFindIndex(array, predicate, fromRight) { |
| var length = array.length, index = fromRight ? length : -1; |
| while (fromRight ? index-- : ++index < length) { |
| if (predicate(array[index], index, array)) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| /** |
| * The base implementation of `_.indexOf` without support for binary searches. |
| * |
| * @private |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {number} fromIndex The index to search from. |
| * @returns {number} Returns the index of the matched value, else `-1`. |
| */ |
| function baseIndexOf(array, value, fromIndex) { |
| if (value !== value) { |
| return indexOfNaN(array, fromIndex); |
| } |
| var index = fromIndex - 1, length = array.length; |
| while (++index < length) { |
| if (array[index] === value) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| /** |
| * The base implementation of `_.isFunction` without support for environments |
| * with incorrect `typeof` results. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| */ |
| function baseIsFunction(value) { |
| // Avoid a Chakra JIT bug in compatibility modes of IE 11. |
| // See https://github.com/jashkenas/underscore/issues/1621 for more details. |
| return typeof value == 'function' || false; |
| } |
| /** |
| * Converts `value` to a string if it's not one. An empty string is returned |
| * for `null` or `undefined` values. |
| * |
| * @private |
| * @param {*} value The value to process. |
| * @returns {string} Returns the string. |
| */ |
| function baseToString(value) { |
| return value == null ? '' : value + ''; |
| } |
| /** |
| * Used by `_.trim` and `_.trimLeft` to get the index of the first character |
| * of `string` that is not found in `chars`. |
| * |
| * @private |
| * @param {string} string The string to inspect. |
| * @param {string} chars The characters to find. |
| * @returns {number} Returns the index of the first character not found in `chars`. |
| */ |
| function charsLeftIndex(string, chars) { |
| var index = -1, length = string.length; |
| while (++index < length && chars.indexOf(string.charAt(index)) > -1) { |
| } |
| return index; |
| } |
| /** |
| * Used by `_.trim` and `_.trimRight` to get the index of the last character |
| * of `string` that is not found in `chars`. |
| * |
| * @private |
| * @param {string} string The string to inspect. |
| * @param {string} chars The characters to find. |
| * @returns {number} Returns the index of the last character not found in `chars`. |
| */ |
| function charsRightIndex(string, chars) { |
| var index = string.length; |
| while (index-- && chars.indexOf(string.charAt(index)) > -1) { |
| } |
| return index; |
| } |
| /** |
| * Used by `_.sortBy` to compare transformed elements of a collection and stable |
| * sort them in ascending order. |
| * |
| * @private |
| * @param {Object} object The object to compare. |
| * @param {Object} other The other object to compare. |
| * @returns {number} Returns the sort order indicator for `object`. |
| */ |
| function compareAscending(object, other) { |
| return baseCompareAscending(object.criteria, other.criteria) || object.index - other.index; |
| } |
| /** |
| * Used by `_.sortByOrder` to compare multiple properties of a value to another |
| * and stable sort them. |
| * |
| * If `orders` is unspecified, all valuess are sorted in ascending order. Otherwise, |
| * a value is sorted in ascending order if its corresponding order is "asc", and |
| * descending if "desc". |
| * |
| * @private |
| * @param {Object} object The object to compare. |
| * @param {Object} other The other object to compare. |
| * @param {boolean[]} orders The order to sort by for each property. |
| * @returns {number} Returns the sort order indicator for `object`. |
| */ |
| function compareMultiple(object, other, orders) { |
| var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length; |
| while (++index < length) { |
| var result = baseCompareAscending(objCriteria[index], othCriteria[index]); |
| if (result) { |
| if (index >= ordersLength) { |
| return result; |
| } |
| var order = orders[index]; |
| return result * (order === 'asc' || order === true ? 1 : -1); |
| } |
| } |
| // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications |
| // that causes it, under certain circumstances, to provide the same value for |
| // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 |
| // for more details. |
| // |
| // This also ensures a stable sort in V8 and other engines. |
| // See https://code.google.com/p/v8/issues/detail?id=90 for more details. |
| return object.index - other.index; |
| } |
| /** |
| * Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters. |
| * |
| * @private |
| * @param {string} letter The matched letter to deburr. |
| * @returns {string} Returns the deburred letter. |
| */ |
| function deburrLetter(letter) { |
| return deburredLetters[letter]; |
| } |
| /** |
| * Used by `_.escape` to convert characters to HTML entities. |
| * |
| * @private |
| * @param {string} chr The matched character to escape. |
| * @returns {string} Returns the escaped character. |
| */ |
| function escapeHtmlChar(chr) { |
| return htmlEscapes[chr]; |
| } |
| /** |
| * Used by `_.escapeRegExp` to escape characters for inclusion in compiled regexes. |
| * |
| * @private |
| * @param {string} chr The matched character to escape. |
| * @param {string} leadingChar The capture group for a leading character. |
| * @param {string} whitespaceChar The capture group for a whitespace character. |
| * @returns {string} Returns the escaped character. |
| */ |
| function escapeRegExpChar(chr, leadingChar, whitespaceChar) { |
| if (leadingChar) { |
| chr = regexpEscapes[chr]; |
| } else if (whitespaceChar) { |
| chr = stringEscapes[chr]; |
| } |
| return '\\' + chr; |
| } |
| /** |
| * Used by `_.template` to escape characters for inclusion in compiled string literals. |
| * |
| * @private |
| * @param {string} chr The matched character to escape. |
| * @returns {string} Returns the escaped character. |
| */ |
| function escapeStringChar(chr) { |
| return '\\' + stringEscapes[chr]; |
| } |
| /** |
| * Gets the index at which the first occurrence of `NaN` is found in `array`. |
| * |
| * @private |
| * @param {Array} array The array to search. |
| * @param {number} fromIndex The index to search from. |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {number} Returns the index of the matched `NaN`, else `-1`. |
| */ |
| function indexOfNaN(array, fromIndex, fromRight) { |
| var length = array.length, index = fromIndex + (fromRight ? 0 : -1); |
| while (fromRight ? index-- : ++index < length) { |
| var other = array[index]; |
| if (other !== other) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| /** |
| * Checks if `value` is object-like. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
| */ |
| function isObjectLike(value) { |
| return !!value && typeof value == 'object'; |
| } |
| /** |
| * Used by `trimmedLeftIndex` and `trimmedRightIndex` to determine if a |
| * character code is whitespace. |
| * |
| * @private |
| * @param {number} charCode The character code to inspect. |
| * @returns {boolean} Returns `true` if `charCode` is whitespace, else `false`. |
| */ |
| function isSpace(charCode) { |
| return charCode <= 160 && (charCode >= 9 && charCode <= 13) || charCode == 32 || charCode == 160 || charCode == 5760 || charCode == 6158 || charCode >= 8192 && (charCode <= 8202 || charCode == 8232 || charCode == 8233 || charCode == 8239 || charCode == 8287 || charCode == 12288 || charCode == 65279); |
| } |
| /** |
| * Replaces all `placeholder` elements in `array` with an internal placeholder |
| * and returns an array of their indexes. |
| * |
| * @private |
| * @param {Array} array The array to modify. |
| * @param {*} placeholder The placeholder to replace. |
| * @returns {Array} Returns the new array of placeholder indexes. |
| */ |
| function replaceHolders(array, placeholder) { |
| var index = -1, length = array.length, resIndex = -1, result = []; |
| while (++index < length) { |
| if (array[index] === placeholder) { |
| array[index] = PLACEHOLDER; |
| result[++resIndex] = index; |
| } |
| } |
| return result; |
| } |
| /** |
| * An implementation of `_.uniq` optimized for sorted arrays without support |
| * for callback shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to inspect. |
| * @param {Function} [iteratee] The function invoked per iteration. |
| * @returns {Array} Returns the new duplicate free array. |
| */ |
| function sortedUniq(array, iteratee) { |
| var seen, index = -1, length = array.length, resIndex = -1, result = []; |
| while (++index < length) { |
| var value = array[index], computed = iteratee ? iteratee(value, index, array) : value; |
| if (!index || seen !== computed) { |
| seen = computed; |
| result[++resIndex] = value; |
| } |
| } |
| return result; |
| } |
| /** |
| * Used by `_.trim` and `_.trimLeft` to get the index of the first non-whitespace |
| * character of `string`. |
| * |
| * @private |
| * @param {string} string The string to inspect. |
| * @returns {number} Returns the index of the first non-whitespace character. |
| */ |
| function trimmedLeftIndex(string) { |
| var index = -1, length = string.length; |
| while (++index < length && isSpace(string.charCodeAt(index))) { |
| } |
| return index; |
| } |
| /** |
| * Used by `_.trim` and `_.trimRight` to get the index of the last non-whitespace |
| * character of `string`. |
| * |
| * @private |
| * @param {string} string The string to inspect. |
| * @returns {number} Returns the index of the last non-whitespace character. |
| */ |
| function trimmedRightIndex(string) { |
| var index = string.length; |
| while (index-- && isSpace(string.charCodeAt(index))) { |
| } |
| return index; |
| } |
| /** |
| * Used by `_.unescape` to convert HTML entities to characters. |
| * |
| * @private |
| * @param {string} chr The matched character to unescape. |
| * @returns {string} Returns the unescaped character. |
| */ |
| function unescapeHtmlChar(chr) { |
| return htmlUnescapes[chr]; |
| } |
| /*--------------------------------------------------------------------------*/ |
| /** |
| * Create a new pristine `lodash` function using the given `context` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Object} [context=root] The context object. |
| * @returns {Function} Returns a new `lodash` function. |
| * @example |
| * |
| * _.mixin({ 'foo': _.constant('foo') }); |
| * |
| * var lodash = _.runInContext(); |
| * lodash.mixin({ 'bar': lodash.constant('bar') }); |
| * |
| * _.isFunction(_.foo); |
| * // => true |
| * _.isFunction(_.bar); |
| * // => false |
| * |
| * lodash.isFunction(lodash.foo); |
| * // => false |
| * lodash.isFunction(lodash.bar); |
| * // => true |
| * |
| * // using `context` to mock `Date#getTime` use in `_.now` |
| * var mock = _.runInContext({ |
| * 'Date': function() { |
| * return { 'getTime': getTimeMock }; |
| * } |
| * }); |
| * |
| * // or creating a suped-up `defer` in Node.js |
| * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; |
| */ |
| function runInContext(context) { |
| // Avoid issues with some ES3 environments that attempt to use values, named |
| // after built-in constructors like `Object`, for the creation of literals. |
| // ES5 clears this up by stating that literals must use built-in constructors. |
| // See https://es5.github.io/#x11.1.5 for more details. |
| context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root; |
| /** Native constructor references. */ |
| var Array = context.Array, Date = context.Date, Error = context.Error, Function = context.Function, Math = context.Math, Number = context.Number, Object = context.Object, RegExp = context.RegExp, String = context.String, TypeError = context.TypeError; |
| /** Used for native method references. */ |
| var arrayProto = Array.prototype, objectProto = Object.prototype, stringProto = String.prototype; |
| /** Used to resolve the decompiled source of functions. */ |
| var fnToString = Function.prototype.toString; |
| /** Used to check objects for own properties. */ |
| var hasOwnProperty = objectProto.hasOwnProperty; |
| /** Used to generate unique IDs. */ |
| var idCounter = 0; |
| /** |
| * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
| * of values. |
| */ |
| var objToString = objectProto.toString; |
| /** Used to restore the original `_` reference in `_.noConflict`. */ |
| var oldDash = root._; |
| /** Used to detect if a method is native. */ |
| var reIsNative = RegExp('^' + fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'); |
| /** Native method references. */ |
| var ArrayBuffer = context.ArrayBuffer, clearTimeout = context.clearTimeout, parseFloat = context.parseFloat, pow = Math.pow, propertyIsEnumerable = objectProto.propertyIsEnumerable, Set = getNative(context, 'Set'), setTimeout = context.setTimeout, splice = arrayProto.splice, Uint8Array = context.Uint8Array, WeakMap = getNative(context, 'WeakMap'); |
| /* Native method references for those with the same name as other `lodash` methods. */ |
| var nativeCeil = Math.ceil, nativeCreate = getNative(Object, 'create'), nativeFloor = Math.floor, nativeIsArray = getNative(Array, 'isArray'), nativeIsFinite = context.isFinite, nativeKeys = getNative(Object, 'keys'), nativeMax = Math.max, nativeMin = Math.min, nativeNow = getNative(Date, 'now'), nativeParseInt = context.parseInt, nativeRandom = Math.random; |
| /** Used as references for `-Infinity` and `Infinity`. */ |
| var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY, POSITIVE_INFINITY = Number.POSITIVE_INFINITY; |
| /** Used as references for the maximum length and index of an array. */ |
| var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; |
| /** |
| * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer) |
| * of an array-like value. |
| */ |
| var MAX_SAFE_INTEGER = 9007199254740991; |
| /** Used to store function metadata. */ |
| var metaMap = WeakMap && new WeakMap(); |
| /** Used to lookup unminified function names. */ |
| var realNames = {}; |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates a `lodash` object which wraps `value` to enable implicit chaining. |
| * Methods that operate on and return arrays, collections, and functions can |
| * be chained together. Methods that retrieve a single value or may return a |
| * primitive value will automatically end the chain returning the unwrapped |
| * value. Explicit chaining may be enabled using `_.chain`. The execution of |
| * chained methods is lazy, that is, execution is deferred until `_#value` |
| * is implicitly or explicitly called. |
| * |
| * Lazy evaluation allows several methods to support shortcut fusion. Shortcut |
| * fusion is an optimization strategy which merge iteratee calls; this can help |
| * to avoid the creation of intermediate data structures and greatly reduce the |
| * number of iteratee executions. |
| * |
| * Chaining is supported in custom builds as long as the `_#value` method is |
| * directly or indirectly included in the build. |
| * |
| * In addition to lodash methods, wrappers have `Array` and `String` methods. |
| * |
| * The wrapper `Array` methods are: |
| * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, |
| * `splice`, and `unshift` |
| * |
| * The wrapper `String` methods are: |
| * `replace` and `split` |
| * |
| * The wrapper methods that support shortcut fusion are: |
| * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`, |
| * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`, |
| * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`, |
| * and `where` |
| * |
| * The chainable wrapper methods are: |
| * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`, |
| * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`, |
| * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defaultsDeep`, |
| * `defer`, `delay`, `difference`, `drop`, `dropRight`, `dropRightWhile`, |
| * `dropWhile`, `fill`, `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`, |
| * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, |
| * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, |
| * `invoke`, `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, |
| * `matchesProperty`, `memoize`, `merge`, `method`, `methodOf`, `mixin`, |
| * `modArgs`, `negate`, `omit`, `once`, `pairs`, `partial`, `partialRight`, |
| * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`, |
| * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `restParam`, |
| * `reverse`, `set`, `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`, |
| * `sortByOrder`, `splice`, `spread`, `take`, `takeRight`, `takeRightWhile`, |
| * `takeWhile`, `tap`, `throttle`, `thru`, `times`, `toArray`, `toPlainObject`, |
| * `transform`, `union`, `uniq`, `unshift`, `unzip`, `unzipWith`, `values`, |
| * `valuesIn`, `where`, `without`, `wrap`, `xor`, `zip`, `zipObject`, `zipWith` |
| * |
| * The wrapper methods that are **not** chainable by default are: |
| * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clone`, `cloneDeep`, |
| * `deburr`, `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`, |
| * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`, |
| * `floor`, `get`, `gt`, `gte`, `has`, `identity`, `includes`, `indexOf`, |
| * `inRange`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, |
| * `isEmpty`, `isEqual`, `isError`, `isFinite` `isFunction`, `isMatch`, |
| * `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`, |
| * `isRegExp`, `isString`, `isUndefined`, `isTypedArray`, `join`, `kebabCase`, |
| * `last`, `lastIndexOf`, `lt`, `lte`, `max`, `min`, `noConflict`, `noop`, |
| * `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, `random`, `reduce`, |
| * `reduceRight`, `repeat`, `result`, `round`, `runInContext`, `shift`, `size`, |
| * `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, `startCase`, |
| * `startsWith`, `sum`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`, |
| * `unescape`, `uniqueId`, `value`, and `words` |
| * |
| * The wrapper method `sample` will return a wrapped value when `n` is provided, |
| * otherwise an unwrapped value is returned. |
| * |
| * @name _ |
| * @constructor |
| * @category Chain |
| * @param {*} value The value to wrap in a `lodash` instance. |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var wrapped = _([1, 2, 3]); |
| * |
| * // returns an unwrapped value |
| * wrapped.reduce(function(total, n) { |
| * return total + n; |
| * }); |
| * // => 6 |
| * |
| * // returns a wrapped value |
| * var squares = wrapped.map(function(n) { |
| * return n * n; |
| * }); |
| * |
| * _.isArray(squares); |
| * // => false |
| * |
| * _.isArray(squares.value()); |
| * // => true |
| */ |
| function lodash(value) { |
| if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { |
| if (value instanceof LodashWrapper) { |
| return value; |
| } |
| if (hasOwnProperty.call(value, '__chain__') && hasOwnProperty.call(value, '__wrapped__')) { |
| return wrapperClone(value); |
| } |
| } |
| return new LodashWrapper(value); |
| } |
| /** |
| * The function whose prototype all chaining wrappers inherit from. |
| * |
| * @private |
| */ |
| function baseLodash() { |
| } |
| /** |
| * The base constructor for creating `lodash` wrapper objects. |
| * |
| * @private |
| * @param {*} value The value to wrap. |
| * @param {boolean} [chainAll] Enable chaining for all wrapper methods. |
| * @param {Array} [actions=[]] Actions to peform to resolve the unwrapped value. |
| */ |
| function LodashWrapper(value, chainAll, actions) { |
| this.__wrapped__ = value; |
| this.__actions__ = actions || []; |
| this.__chain__ = !!chainAll; |
| } |
| /** |
| * An object environment feature flags. |
| * |
| * @static |
| * @memberOf _ |
| * @type Object |
| */ |
| var support = lodash.support = {}; |
| /** |
| * By default, the template delimiters used by lodash are like those in |
| * embedded Ruby (ERB). Change the following template settings to use |
| * alternative delimiters. |
| * |
| * @static |
| * @memberOf _ |
| * @type Object |
| */ |
| lodash.templateSettings = { |
| 'escape': reEscape, |
| 'evaluate': reEvaluate, |
| 'interpolate': reInterpolate, |
| 'variable': '', |
| 'imports': { '_': lodash } |
| }; |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. |
| * |
| * @private |
| * @param {*} value The value to wrap. |
| */ |
| function LazyWrapper(value) { |
| this.__wrapped__ = value; |
| this.__actions__ = []; |
| this.__dir__ = 1; |
| this.__filtered__ = false; |
| this.__iteratees__ = []; |
| this.__takeCount__ = POSITIVE_INFINITY; |
| this.__views__ = []; |
| } |
| /** |
| * Creates a clone of the lazy wrapper object. |
| * |
| * @private |
| * @name clone |
| * @memberOf LazyWrapper |
| * @returns {Object} Returns the cloned `LazyWrapper` object. |
| */ |
| function lazyClone() { |
| var result = new LazyWrapper(this.__wrapped__); |
| result.__actions__ = arrayCopy(this.__actions__); |
| result.__dir__ = this.__dir__; |
| result.__filtered__ = this.__filtered__; |
| result.__iteratees__ = arrayCopy(this.__iteratees__); |
| result.__takeCount__ = this.__takeCount__; |
| result.__views__ = arrayCopy(this.__views__); |
| return result; |
| } |
| /** |
| * Reverses the direction of lazy iteration. |
| * |
| * @private |
| * @name reverse |
| * @memberOf LazyWrapper |
| * @returns {Object} Returns the new reversed `LazyWrapper` object. |
| */ |
| function lazyReverse() { |
| if (this.__filtered__) { |
| var result = new LazyWrapper(this); |
| result.__dir__ = -1; |
| result.__filtered__ = true; |
| } else { |
| result = this.clone(); |
| result.__dir__ *= -1; |
| } |
| return result; |
| } |
| /** |
| * Extracts the unwrapped value from its lazy wrapper. |
| * |
| * @private |
| * @name value |
| * @memberOf LazyWrapper |
| * @returns {*} Returns the unwrapped value. |
| */ |
| function lazyValue() { |
| var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__); |
| if (!isArr || arrLength < LARGE_ARRAY_SIZE || arrLength == length && takeCount == length) { |
| return baseWrapperValue(array, this.__actions__); |
| } |
| var result = []; |
| outer: |
| while (length-- && resIndex < takeCount) { |
| index += dir; |
| var iterIndex = -1, value = array[index]; |
| while (++iterIndex < iterLength) { |
| var data = iteratees[iterIndex], iteratee = data.iteratee, type = data.type, computed = iteratee(value); |
| if (type == LAZY_MAP_FLAG) { |
| value = computed; |
| } else if (!computed) { |
| if (type == LAZY_FILTER_FLAG) { |
| continue outer; |
| } else { |
| break outer; |
| } |
| } |
| } |
| result[resIndex++] = value; |
| } |
| return result; |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates a cache object to store key/value pairs. |
| * |
| * @private |
| * @static |
| * @name Cache |
| * @memberOf _.memoize |
| */ |
| function MapCache() { |
| this.__data__ = {}; |
| } |
| /** |
| * Removes `key` and its value from the cache. |
| * |
| * @private |
| * @name delete |
| * @memberOf _.memoize.Cache |
| * @param {string} key The key of the value to remove. |
| * @returns {boolean} Returns `true` if the entry was removed successfully, else `false`. |
| */ |
| function mapDelete(key) { |
| return this.has(key) && delete this.__data__[key]; |
| } |
| /** |
| * Gets the cached value for `key`. |
| * |
| * @private |
| * @name get |
| * @memberOf _.memoize.Cache |
| * @param {string} key The key of the value to get. |
| * @returns {*} Returns the cached value. |
| */ |
| function mapGet(key) { |
| return key == '__proto__' ? undefined : this.__data__[key]; |
| } |
| /** |
| * Checks if a cached value for `key` exists. |
| * |
| * @private |
| * @name has |
| * @memberOf _.memoize.Cache |
| * @param {string} key The key of the entry to check. |
| * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| */ |
| function mapHas(key) { |
| return key != '__proto__' && hasOwnProperty.call(this.__data__, key); |
| } |
| /** |
| * Sets `value` to `key` of the cache. |
| * |
| * @private |
| * @name set |
| * @memberOf _.memoize.Cache |
| * @param {string} key The key of the value to cache. |
| * @param {*} value The value to cache. |
| * @returns {Object} Returns the cache object. |
| */ |
| function mapSet(key, value) { |
| if (key != '__proto__') { |
| this.__data__[key] = value; |
| } |
| return this; |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * |
| * Creates a cache object to store unique values. |
| * |
| * @private |
| * @param {Array} [values] The values to cache. |
| */ |
| function SetCache(values) { |
| var length = values ? values.length : 0; |
| this.data = { |
| 'hash': nativeCreate(null), |
| 'set': new Set() |
| }; |
| while (length--) { |
| this.push(values[length]); |
| } |
| } |
| /** |
| * Checks if `value` is in `cache` mimicking the return signature of |
| * `_.indexOf` by returning `0` if the value is found, else `-1`. |
| * |
| * @private |
| * @param {Object} cache The cache to search. |
| * @param {*} value The value to search for. |
| * @returns {number} Returns `0` if `value` is found, else `-1`. |
| */ |
| function cacheIndexOf(cache, value) { |
| var data = cache.data, result = typeof value == 'string' || isObject(value) ? data.set.has(value) : data.hash[value]; |
| return result ? 0 : -1; |
| } |
| /** |
| * Adds `value` to the cache. |
| * |
| * @private |
| * @name push |
| * @memberOf SetCache |
| * @param {*} value The value to cache. |
| */ |
| function cachePush(value) { |
| var data = this.data; |
| if (typeof value == 'string' || isObject(value)) { |
| data.set.add(value); |
| } else { |
| data.hash[value] = true; |
| } |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates a new array joining `array` with `other`. |
| * |
| * @private |
| * @param {Array} array The array to join. |
| * @param {Array} other The other array to join. |
| * @returns {Array} Returns the new concatenated array. |
| */ |
| function arrayConcat(array, other) { |
| var index = -1, length = array.length, othIndex = -1, othLength = other.length, result = Array(length + othLength); |
| while (++index < length) { |
| result[index] = array[index]; |
| } |
| while (++othIndex < othLength) { |
| result[index++] = other[othIndex]; |
| } |
| return result; |
| } |
| /** |
| * Copies the values of `source` to `array`. |
| * |
| * @private |
| * @param {Array} source The array to copy values from. |
| * @param {Array} [array=[]] The array to copy values to. |
| * @returns {Array} Returns `array`. |
| */ |
| function arrayCopy(source, array) { |
| var index = -1, length = source.length; |
| array || (array = Array(length)); |
| while (++index < length) { |
| array[index] = source[index]; |
| } |
| return array; |
| } |
| /** |
| * A specialized version of `_.forEach` for arrays without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array} Returns `array`. |
| */ |
| function arrayEach(array, iteratee) { |
| var index = -1, length = array.length; |
| while (++index < length) { |
| if (iteratee(array[index], index, array) === false) { |
| break; |
| } |
| } |
| return array; |
| } |
| /** |
| * A specialized version of `_.forEachRight` for arrays without support for |
| * callback shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array} Returns `array`. |
| */ |
| function arrayEachRight(array, iteratee) { |
| var length = array.length; |
| while (length--) { |
| if (iteratee(array[length], length, array) === false) { |
| break; |
| } |
| } |
| return array; |
| } |
| /** |
| * A specialized version of `_.every` for arrays without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {boolean} Returns `true` if all elements pass the predicate check, |
| * else `false`. |
| */ |
| function arrayEvery(array, predicate) { |
| var index = -1, length = array.length; |
| while (++index < length) { |
| if (!predicate(array[index], index, array)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| /** |
| * A specialized version of `baseExtremum` for arrays which invokes `iteratee` |
| * with one argument: (value). |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {Function} comparator The function used to compare values. |
| * @param {*} exValue The initial extremum value. |
| * @returns {*} Returns the extremum value. |
| */ |
| function arrayExtremum(array, iteratee, comparator, exValue) { |
| var index = -1, length = array.length, computed = exValue, result = computed; |
| while (++index < length) { |
| var value = array[index], current = +iteratee(value); |
| if (comparator(current, computed)) { |
| computed = current; |
| result = value; |
| } |
| } |
| return result; |
| } |
| /** |
| * A specialized version of `_.filter` for arrays without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {Array} Returns the new filtered array. |
| */ |
| function arrayFilter(array, predicate) { |
| var index = -1, length = array.length, resIndex = -1, result = []; |
| while (++index < length) { |
| var value = array[index]; |
| if (predicate(value, index, array)) { |
| result[++resIndex] = value; |
| } |
| } |
| return result; |
| } |
| /** |
| * A specialized version of `_.map` for arrays without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array} Returns the new mapped array. |
| */ |
| function arrayMap(array, iteratee) { |
| var index = -1, length = array.length, result = Array(length); |
| while (++index < length) { |
| result[index] = iteratee(array[index], index, array); |
| } |
| return result; |
| } |
| /** |
| * Appends the elements of `values` to `array`. |
| * |
| * @private |
| * @param {Array} array The array to modify. |
| * @param {Array} values The values to append. |
| * @returns {Array} Returns `array`. |
| */ |
| function arrayPush(array, values) { |
| var index = -1, length = values.length, offset = array.length; |
| while (++index < length) { |
| array[offset + index] = values[index]; |
| } |
| return array; |
| } |
| /** |
| * A specialized version of `_.reduce` for arrays without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {*} [accumulator] The initial value. |
| * @param {boolean} [initFromArray] Specify using the first element of `array` |
| * as the initial value. |
| * @returns {*} Returns the accumulated value. |
| */ |
| function arrayReduce(array, iteratee, accumulator, initFromArray) { |
| var index = -1, length = array.length; |
| if (initFromArray && length) { |
| accumulator = array[++index]; |
| } |
| while (++index < length) { |
| accumulator = iteratee(accumulator, array[index], index, array); |
| } |
| return accumulator; |
| } |
| /** |
| * A specialized version of `_.reduceRight` for arrays without support for |
| * callback shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {*} [accumulator] The initial value. |
| * @param {boolean} [initFromArray] Specify using the last element of `array` |
| * as the initial value. |
| * @returns {*} Returns the accumulated value. |
| */ |
| function arrayReduceRight(array, iteratee, accumulator, initFromArray) { |
| var length = array.length; |
| if (initFromArray && length) { |
| accumulator = array[--length]; |
| } |
| while (length--) { |
| accumulator = iteratee(accumulator, array[length], length, array); |
| } |
| return accumulator; |
| } |
| /** |
| * A specialized version of `_.some` for arrays without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {boolean} Returns `true` if any element passes the predicate check, |
| * else `false`. |
| */ |
| function arraySome(array, predicate) { |
| var index = -1, length = array.length; |
| while (++index < length) { |
| if (predicate(array[index], index, array)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| /** |
| * A specialized version of `_.sum` for arrays without support for callback |
| * shorthands and `this` binding.. |
| * |
| * @private |
| * @param {Array} array The array to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {number} Returns the sum. |
| */ |
| function arraySum(array, iteratee) { |
| var length = array.length, result = 0; |
| while (length--) { |
| result += +iteratee(array[length]) || 0; |
| } |
| return result; |
| } |
| /** |
| * Used by `_.defaults` to customize its `_.assign` use. |
| * |
| * @private |
| * @param {*} objectValue The destination object property value. |
| * @param {*} sourceValue The source object property value. |
| * @returns {*} Returns the value to assign to the destination object. |
| */ |
| function assignDefaults(objectValue, sourceValue) { |
| return objectValue === undefined ? sourceValue : objectValue; |
| } |
| /** |
| * Used by `_.template` to customize its `_.assign` use. |
| * |
| * **Note:** This function is like `assignDefaults` except that it ignores |
| * inherited property values when checking if a property is `undefined`. |
| * |
| * @private |
| * @param {*} objectValue The destination object property value. |
| * @param {*} sourceValue The source object property value. |
| * @param {string} key The key associated with the object and source values. |
| * @param {Object} object The destination object. |
| * @returns {*} Returns the value to assign to the destination object. |
| */ |
| function assignOwnDefaults(objectValue, sourceValue, key, object) { |
| return objectValue === undefined || !hasOwnProperty.call(object, key) ? sourceValue : objectValue; |
| } |
| /** |
| * A specialized version of `_.assign` for customizing assigned values without |
| * support for argument juggling, multiple sources, and `this` binding `customizer` |
| * functions. |
| * |
| * @private |
| * @param {Object} object The destination object. |
| * @param {Object} source The source object. |
| * @param {Function} customizer The function to customize assigned values. |
| * @returns {Object} Returns `object`. |
| */ |
| function assignWith(object, source, customizer) { |
| var index = -1, props = keys(source), length = props.length; |
| while (++index < length) { |
| var key = props[index], value = object[key], result = customizer(value, source[key], key, object, source); |
| if ((result === result ? result !== value : value === value) || value === undefined && !(key in object)) { |
| object[key] = result; |
| } |
| } |
| return object; |
| } |
| /** |
| * The base implementation of `_.assign` without support for argument juggling, |
| * multiple sources, and `customizer` functions. |
| * |
| * @private |
| * @param {Object} object The destination object. |
| * @param {Object} source The source object. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseAssign(object, source) { |
| return source == null ? object : baseCopy(source, keys(source), object); |
| } |
| /** |
| * The base implementation of `_.at` without support for string collections |
| * and individual key arguments. |
| * |
| * @private |
| * @param {Array|Object} collection The collection to iterate over. |
| * @param {number[]|string[]} props The property names or indexes of elements to pick. |
| * @returns {Array} Returns the new array of picked elements. |
| */ |
| function baseAt(collection, props) { |
| var index = -1, isNil = collection == null, isArr = !isNil && isArrayLike(collection), length = isArr ? collection.length : 0, propsLength = props.length, result = Array(propsLength); |
| while (++index < propsLength) { |
| var key = props[index]; |
| if (isArr) { |
| result[index] = isIndex(key, length) ? collection[key] : undefined; |
| } else { |
| result[index] = isNil ? undefined : collection[key]; |
| } |
| } |
| return result; |
| } |
| /** |
| * Copies properties of `source` to `object`. |
| * |
| * @private |
| * @param {Object} source The object to copy properties from. |
| * @param {Array} props The property names to copy. |
| * @param {Object} [object={}] The object to copy properties to. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseCopy(source, props, object) { |
| object || (object = {}); |
| var index = -1, length = props.length; |
| while (++index < length) { |
| var key = props[index]; |
| object[key] = source[key]; |
| } |
| return object; |
| } |
| /** |
| * The base implementation of `_.callback` which supports specifying the |
| * number of arguments to provide to `func`. |
| * |
| * @private |
| * @param {*} [func=_.identity] The value to convert to a callback. |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @param {number} [argCount] The number of arguments to provide to `func`. |
| * @returns {Function} Returns the callback. |
| */ |
| function baseCallback(func, thisArg, argCount) { |
| var type = typeof func; |
| if (type == 'function') { |
| return thisArg === undefined ? func : bindCallback(func, thisArg, argCount); |
| } |
| if (func == null) { |
| return identity; |
| } |
| if (type == 'object') { |
| return baseMatches(func); |
| } |
| return thisArg === undefined ? property(func) : baseMatchesProperty(func, thisArg); |
| } |
| /** |
| * The base implementation of `_.clone` without support for argument juggling |
| * and `this` binding `customizer` functions. |
| * |
| * @private |
| * @param {*} value The value to clone. |
| * @param {boolean} [isDeep] Specify a deep clone. |
| * @param {Function} [customizer] The function to customize cloning values. |
| * @param {string} [key] The key of `value`. |
| * @param {Object} [object] The object `value` belongs to. |
| * @param {Array} [stackA=[]] Tracks traversed source objects. |
| * @param {Array} [stackB=[]] Associates clones with source counterparts. |
| * @returns {*} Returns the cloned value. |
| */ |
| function baseClone(value, isDeep, customizer, key, object, stackA, stackB) { |
| var result; |
| if (customizer) { |
| result = object ? customizer(value, key, object) : customizer(value); |
| } |
| if (result !== undefined) { |
| return result; |
| } |
| if (!isObject(value)) { |
| return value; |
| } |
| var isArr = isArray(value); |
| if (isArr) { |
| result = initCloneArray(value); |
| if (!isDeep) { |
| return arrayCopy(value, result); |
| } |
| } else { |
| var tag = objToString.call(value), isFunc = tag == funcTag; |
| if (tag == objectTag || tag == argsTag || isFunc && !object) { |
| result = initCloneObject(isFunc ? {} : value); |
| if (!isDeep) { |
| return baseAssign(result, value); |
| } |
| } else { |
| return cloneableTags[tag] ? initCloneByTag(value, tag, isDeep) : object ? value : {}; |
| } |
| } |
| // Check for circular references and return its corresponding clone. |
| stackA || (stackA = []); |
| stackB || (stackB = []); |
| var length = stackA.length; |
| while (length--) { |
| if (stackA[length] == value) { |
| return stackB[length]; |
| } |
| } |
| // Add the source value to the stack of traversed objects and associate it with its clone. |
| stackA.push(value); |
| stackB.push(result); |
| // Recursively populate clone (susceptible to call stack limits). |
| (isArr ? arrayEach : baseForOwn)(value, function (subValue, key) { |
| result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB); |
| }); |
| return result; |
| } |
| /** |
| * The base implementation of `_.create` without support for assigning |
| * properties to the created object. |
| * |
| * @private |
| * @param {Object} prototype The object to inherit from. |
| * @returns {Object} Returns the new object. |
| */ |
| var baseCreate = function () { |
| function object() { |
| } |
| return function (prototype) { |
| if (isObject(prototype)) { |
| object.prototype = prototype; |
| var result = new object(); |
| object.prototype = undefined; |
| } |
| return result || {}; |
| }; |
| }(); |
| /** |
| * The base implementation of `_.delay` and `_.defer` which accepts an index |
| * of where to slice the arguments to provide to `func`. |
| * |
| * @private |
| * @param {Function} func The function to delay. |
| * @param {number} wait The number of milliseconds to delay invocation. |
| * @param {Object} args The arguments provide to `func`. |
| * @returns {number} Returns the timer id. |
| */ |
| function baseDelay(func, wait, args) { |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| return setTimeout(function () { |
| func.apply(undefined, args); |
| }, wait); |
| } |
| /** |
| * The base implementation of `_.difference` which accepts a single array |
| * of values to exclude. |
| * |
| * @private |
| * @param {Array} array The array to inspect. |
| * @param {Array} values The values to exclude. |
| * @returns {Array} Returns the new array of filtered values. |
| */ |
| function baseDifference(array, values) { |
| var length = array ? array.length : 0, result = []; |
| if (!length) { |
| return result; |
| } |
| var index = -1, indexOf = getIndexOf(), isCommon = indexOf === baseIndexOf, cache = isCommon && values.length >= LARGE_ARRAY_SIZE ? createCache(values) : null, valuesLength = values.length; |
| if (cache) { |
| indexOf = cacheIndexOf; |
| isCommon = false; |
| values = cache; |
| } |
| outer: |
| while (++index < length) { |
| var value = array[index]; |
| if (isCommon && value === value) { |
| var valuesIndex = valuesLength; |
| while (valuesIndex--) { |
| if (values[valuesIndex] === value) { |
| continue outer; |
| } |
| } |
| result.push(value); |
| } else if (indexOf(values, value, 0) < 0) { |
| result.push(value); |
| } |
| } |
| return result; |
| } |
| /** |
| * The base implementation of `_.forEach` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array|Object|string} Returns `collection`. |
| */ |
| var baseEach = createBaseEach(baseForOwn); |
| /** |
| * The base implementation of `_.forEachRight` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array|Object|string} Returns `collection`. |
| */ |
| var baseEachRight = createBaseEach(baseForOwnRight, true); |
| /** |
| * The base implementation of `_.every` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {boolean} Returns `true` if all elements pass the predicate check, |
| * else `false` |
| */ |
| function baseEvery(collection, predicate) { |
| var result = true; |
| baseEach(collection, function (value, index, collection) { |
| result = !!predicate(value, index, collection); |
| return result; |
| }); |
| return result; |
| } |
| /** |
| * Gets the extremum value of `collection` invoking `iteratee` for each value |
| * in `collection` to generate the criterion by which the value is ranked. |
| * The `iteratee` is invoked with three arguments: (value, index|key, collection). |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {Function} comparator The function used to compare values. |
| * @param {*} exValue The initial extremum value. |
| * @returns {*} Returns the extremum value. |
| */ |
| function baseExtremum(collection, iteratee, comparator, exValue) { |
| var computed = exValue, result = computed; |
| baseEach(collection, function (value, index, collection) { |
| var current = +iteratee(value, index, collection); |
| if (comparator(current, computed) || current === exValue && current === result) { |
| computed = current; |
| result = value; |
| } |
| }); |
| return result; |
| } |
| /** |
| * The base implementation of `_.fill` without an iteratee call guard. |
| * |
| * @private |
| * @param {Array} array The array to fill. |
| * @param {*} value The value to fill `array` with. |
| * @param {number} [start=0] The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns `array`. |
| */ |
| function baseFill(array, value, start, end) { |
| var length = array.length; |
| start = start == null ? 0 : +start || 0; |
| if (start < 0) { |
| start = -start > length ? 0 : length + start; |
| } |
| end = end === undefined || end > length ? length : +end || 0; |
| if (end < 0) { |
| end += length; |
| } |
| length = start > end ? 0 : end >>> 0; |
| start >>>= 0; |
| while (start < length) { |
| array[start++] = value; |
| } |
| return array; |
| } |
| /** |
| * The base implementation of `_.filter` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {Array} Returns the new filtered array. |
| */ |
| function baseFilter(collection, predicate) { |
| var result = []; |
| baseEach(collection, function (value, index, collection) { |
| if (predicate(value, index, collection)) { |
| result.push(value); |
| } |
| }); |
| return result; |
| } |
| /** |
| * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`, |
| * without support for callback shorthands and `this` binding, which iterates |
| * over `collection` using the provided `eachFunc`. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to search. |
| * @param {Function} predicate The function invoked per iteration. |
| * @param {Function} eachFunc The function to iterate over `collection`. |
| * @param {boolean} [retKey] Specify returning the key of the found element |
| * instead of the element itself. |
| * @returns {*} Returns the found element or its key, else `undefined`. |
| */ |
| function baseFind(collection, predicate, eachFunc, retKey) { |
| var result; |
| eachFunc(collection, function (value, key, collection) { |
| if (predicate(value, key, collection)) { |
| result = retKey ? key : value; |
| return false; |
| } |
| }); |
| return result; |
| } |
| /** |
| * The base implementation of `_.flatten` with added support for restricting |
| * flattening and specifying the start index. |
| * |
| * @private |
| * @param {Array} array The array to flatten. |
| * @param {boolean} [isDeep] Specify a deep flatten. |
| * @param {boolean} [isStrict] Restrict flattening to arrays-like objects. |
| * @param {Array} [result=[]] The initial result value. |
| * @returns {Array} Returns the new flattened array. |
| */ |
| function baseFlatten(array, isDeep, isStrict, result) { |
| result || (result = []); |
| var index = -1, length = array.length; |
| while (++index < length) { |
| var value = array[index]; |
| if (isObjectLike(value) && isArrayLike(value) && (isStrict || isArray(value) || isArguments(value))) { |
| if (isDeep) { |
| // Recursively flatten arrays (susceptible to call stack limits). |
| baseFlatten(value, isDeep, isStrict, result); |
| } else { |
| arrayPush(result, value); |
| } |
| } else if (!isStrict) { |
| result[result.length] = value; |
| } |
| } |
| return result; |
| } |
| /** |
| * The base implementation of `baseForIn` and `baseForOwn` which iterates |
| * over `object` properties returned by `keysFunc` invoking `iteratee` for |
| * each property. Iteratee functions may exit iteration early by explicitly |
| * returning `false`. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {Function} keysFunc The function to get the keys of `object`. |
| * @returns {Object} Returns `object`. |
| */ |
| var baseFor = createBaseFor(); |
| /** |
| * This function is like `baseFor` except that it iterates over properties |
| * in the opposite order. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {Function} keysFunc The function to get the keys of `object`. |
| * @returns {Object} Returns `object`. |
| */ |
| var baseForRight = createBaseFor(true); |
| /** |
| * The base implementation of `_.forIn` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseForIn(object, iteratee) { |
| return baseFor(object, iteratee, keysIn); |
| } |
| /** |
| * The base implementation of `_.forOwn` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseForOwn(object, iteratee) { |
| return baseFor(object, iteratee, keys); |
| } |
| /** |
| * The base implementation of `_.forOwnRight` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Object} object The object to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseForOwnRight(object, iteratee) { |
| return baseForRight(object, iteratee, keys); |
| } |
| /** |
| * The base implementation of `_.functions` which creates an array of |
| * `object` function property names filtered from those provided. |
| * |
| * @private |
| * @param {Object} object The object to inspect. |
| * @param {Array} props The property names to filter. |
| * @returns {Array} Returns the new array of filtered property names. |
| */ |
| function baseFunctions(object, props) { |
| var index = -1, length = props.length, resIndex = -1, result = []; |
| while (++index < length) { |
| var key = props[index]; |
| if (isFunction(object[key])) { |
| result[++resIndex] = key; |
| } |
| } |
| return result; |
| } |
| /** |
| * The base implementation of `get` without support for string paths |
| * and default values. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {Array} path The path of the property to get. |
| * @param {string} [pathKey] The key representation of path. |
| * @returns {*} Returns the resolved value. |
| */ |
| function baseGet(object, path, pathKey) { |
| if (object == null) { |
| return; |
| } |
| if (pathKey !== undefined && pathKey in toObject(object)) { |
| path = [pathKey]; |
| } |
| var index = 0, length = path.length; |
| while (object != null && index < length) { |
| object = object[path[index++]]; |
| } |
| return index && index == length ? object : undefined; |
| } |
| /** |
| * The base implementation of `_.isEqual` without support for `this` binding |
| * `customizer` functions. |
| * |
| * @private |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @param {Function} [customizer] The function to customize comparing values. |
| * @param {boolean} [isLoose] Specify performing partial comparisons. |
| * @param {Array} [stackA] Tracks traversed `value` objects. |
| * @param {Array} [stackB] Tracks traversed `other` objects. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| */ |
| function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) { |
| if (value === other) { |
| return true; |
| } |
| if (value == null || other == null || !isObject(value) && !isObjectLike(other)) { |
| return value !== value && other !== other; |
| } |
| return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB); |
| } |
| /** |
| * A specialized version of `baseIsEqual` for arrays and objects which performs |
| * deep comparisons and tracks traversed objects enabling objects with circular |
| * references to be compared. |
| * |
| * @private |
| * @param {Object} object The object to compare. |
| * @param {Object} other The other object to compare. |
| * @param {Function} equalFunc The function to determine equivalents of values. |
| * @param {Function} [customizer] The function to customize comparing objects. |
| * @param {boolean} [isLoose] Specify performing partial comparisons. |
| * @param {Array} [stackA=[]] Tracks traversed `value` objects. |
| * @param {Array} [stackB=[]] Tracks traversed `other` objects. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) { |
| var objIsArr = isArray(object), othIsArr = isArray(other), objTag = arrayTag, othTag = arrayTag; |
| if (!objIsArr) { |
| objTag = objToString.call(object); |
| if (objTag == argsTag) { |
| objTag = objectTag; |
| } else if (objTag != objectTag) { |
| objIsArr = isTypedArray(object); |
| } |
| } |
| if (!othIsArr) { |
| othTag = objToString.call(other); |
| if (othTag == argsTag) { |
| othTag = objectTag; |
| } else if (othTag != objectTag) { |
| othIsArr = isTypedArray(other); |
| } |
| } |
| var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag; |
| if (isSameTag && !(objIsArr || objIsObj)) { |
| return equalByTag(object, other, objTag); |
| } |
| if (!isLoose) { |
| var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); |
| if (objIsWrapped || othIsWrapped) { |
| return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB); |
| } |
| } |
| if (!isSameTag) { |
| return false; |
| } |
| // Assume cyclic values are equal. |
| // For more information on detecting circular references see https://es5.github.io/#JO. |
| stackA || (stackA = []); |
| stackB || (stackB = []); |
| var length = stackA.length; |
| while (length--) { |
| if (stackA[length] == object) { |
| return stackB[length] == other; |
| } |
| } |
| // Add `object` and `other` to the stack of traversed objects. |
| stackA.push(object); |
| stackB.push(other); |
| var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB); |
| stackA.pop(); |
| stackB.pop(); |
| return result; |
| } |
| /** |
| * The base implementation of `_.isMatch` without support for callback |
| * shorthands and `this` binding. |
| * |
| * @private |
| * @param {Object} object The object to inspect. |
| * @param {Array} matchData The propery names, values, and compare flags to match. |
| * @param {Function} [customizer] The function to customize comparing objects. |
| * @returns {boolean} Returns `true` if `object` is a match, else `false`. |
| */ |
| function baseIsMatch(object, matchData, customizer) { |
| var index = matchData.length, length = index, noCustomizer = !customizer; |
| if (object == null) { |
| return !length; |
| } |
| object = toObject(object); |
| while (index--) { |
| var data = matchData[index]; |
| if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) { |
| return false; |
| } |
| } |
| while (++index < length) { |
| data = matchData[index]; |
| var key = data[0], objValue = object[key], srcValue = data[1]; |
| if (noCustomizer && data[2]) { |
| if (objValue === undefined && !(key in object)) { |
| return false; |
| } |
| } else { |
| var result = customizer ? customizer(objValue, srcValue, key) : undefined; |
| if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| /** |
| * The base implementation of `_.map` without support for callback shorthands |
| * and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {Array} Returns the new mapped array. |
| */ |
| function baseMap(collection, iteratee) { |
| var index = -1, result = isArrayLike(collection) ? Array(collection.length) : []; |
| baseEach(collection, function (value, key, collection) { |
| result[++index] = iteratee(value, key, collection); |
| }); |
| return result; |
| } |
| /** |
| * The base implementation of `_.matches` which does not clone `source`. |
| * |
| * @private |
| * @param {Object} source The object of property values to match. |
| * @returns {Function} Returns the new function. |
| */ |
| function baseMatches(source) { |
| var matchData = getMatchData(source); |
| if (matchData.length == 1 && matchData[0][2]) { |
| var key = matchData[0][0], value = matchData[0][1]; |
| return function (object) { |
| if (object == null) { |
| return false; |
| } |
| return object[key] === value && (value !== undefined || key in toObject(object)); |
| }; |
| } |
| return function (object) { |
| return baseIsMatch(object, matchData); |
| }; |
| } |
| /** |
| * The base implementation of `_.matchesProperty` which does not clone `srcValue`. |
| * |
| * @private |
| * @param {string} path The path of the property to get. |
| * @param {*} srcValue The value to compare. |
| * @returns {Function} Returns the new function. |
| */ |
| function baseMatchesProperty(path, srcValue) { |
| var isArr = isArray(path), isCommon = isKey(path) && isStrictComparable(srcValue), pathKey = path + ''; |
| path = toPath(path); |
| return function (object) { |
| if (object == null) { |
| return false; |
| } |
| var key = pathKey; |
| object = toObject(object); |
| if ((isArr || !isCommon) && !(key in object)) { |
| object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1)); |
| if (object == null) { |
| return false; |
| } |
| key = last(path); |
| object = toObject(object); |
| } |
| return object[key] === srcValue ? srcValue !== undefined || key in object : baseIsEqual(srcValue, object[key], undefined, true); |
| }; |
| } |
| /** |
| * The base implementation of `_.merge` without support for argument juggling, |
| * multiple sources, and `this` binding `customizer` functions. |
| * |
| * @private |
| * @param {Object} object The destination object. |
| * @param {Object} source The source object. |
| * @param {Function} [customizer] The function to customize merged values. |
| * @param {Array} [stackA=[]] Tracks traversed source objects. |
| * @param {Array} [stackB=[]] Associates values with source counterparts. |
| * @returns {Object} Returns `object`. |
| */ |
| function baseMerge(object, source, customizer, stackA, stackB) { |
| if (!isObject(object)) { |
| return object; |
| } |
| var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source)), props = isSrcArr ? undefined : keys(source); |
| arrayEach(props || source, function (srcValue, key) { |
| if (props) { |
| key = srcValue; |
| srcValue = source[key]; |
| } |
| if (isObjectLike(srcValue)) { |
| stackA || (stackA = []); |
| stackB || (stackB = []); |
| baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB); |
| } else { |
| var value = object[key], result = customizer ? customizer(value, srcValue, key, object, source) : undefined, isCommon = result === undefined; |
| if (isCommon) { |
| result = srcValue; |
| } |
| if ((result !== undefined || isSrcArr && !(key in object)) && (isCommon || (result === result ? result !== value : value === value))) { |
| object[key] = result; |
| } |
| } |
| }); |
| return object; |
| } |
| /** |
| * A specialized version of `baseMerge` for arrays and objects which performs |
| * deep merges and tracks traversed objects enabling objects with circular |
| * references to be merged. |
| * |
| * @private |
| * @param {Object} object The destination object. |
| * @param {Object} source The source object. |
| * @param {string} key The key of the value to merge. |
| * @param {Function} mergeFunc The function to merge values. |
| * @param {Function} [customizer] The function to customize merged values. |
| * @param {Array} [stackA=[]] Tracks traversed source objects. |
| * @param {Array} [stackB=[]] Associates values with source counterparts. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) { |
| var length = stackA.length, srcValue = source[key]; |
| while (length--) { |
| if (stackA[length] == srcValue) { |
| object[key] = stackB[length]; |
| return; |
| } |
| } |
| var value = object[key], result = customizer ? customizer(value, srcValue, key, object, source) : undefined, isCommon = result === undefined; |
| if (isCommon) { |
| result = srcValue; |
| if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) { |
| result = isArray(value) ? value : isArrayLike(value) ? arrayCopy(value) : []; |
| } else if (isPlainObject(srcValue) || isArguments(srcValue)) { |
| result = isArguments(value) ? toPlainObject(value) : isPlainObject(value) ? value : {}; |
| } else { |
| isCommon = false; |
| } |
| } |
| // Add the source value to the stack of traversed objects and associate |
| // it with its merged value. |
| stackA.push(srcValue); |
| stackB.push(result); |
| if (isCommon) { |
| // Recursively merge objects and arrays (susceptible to call stack limits). |
| object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB); |
| } else if (result === result ? result !== value : value === value) { |
| object[key] = result; |
| } |
| } |
| /** |
| * The base implementation of `_.property` without support for deep paths. |
| * |
| * @private |
| * @param {string} key The key of the property to get. |
| * @returns {Function} Returns the new function. |
| */ |
| function baseProperty(key) { |
| return function (object) { |
| return object == null ? undefined : object[key]; |
| }; |
| } |
| /** |
| * A specialized version of `baseProperty` which supports deep paths. |
| * |
| * @private |
| * @param {Array|string} path The path of the property to get. |
| * @returns {Function} Returns the new function. |
| */ |
| function basePropertyDeep(path) { |
| var pathKey = path + ''; |
| path = toPath(path); |
| return function (object) { |
| return baseGet(object, path, pathKey); |
| }; |
| } |
| /** |
| * The base implementation of `_.pullAt` without support for individual |
| * index arguments and capturing the removed elements. |
| * |
| * @private |
| * @param {Array} array The array to modify. |
| * @param {number[]} indexes The indexes of elements to remove. |
| * @returns {Array} Returns `array`. |
| */ |
| function basePullAt(array, indexes) { |
| var length = array ? indexes.length : 0; |
| while (length--) { |
| var index = indexes[length]; |
| if (index != previous && isIndex(index)) { |
| var previous = index; |
| splice.call(array, index, 1); |
| } |
| } |
| return array; |
| } |
| /** |
| * The base implementation of `_.random` without support for argument juggling |
| * and returning floating-point numbers. |
| * |
| * @private |
| * @param {number} min The minimum possible value. |
| * @param {number} max The maximum possible value. |
| * @returns {number} Returns the random number. |
| */ |
| function baseRandom(min, max) { |
| return min + nativeFloor(nativeRandom() * (max - min + 1)); |
| } |
| /** |
| * The base implementation of `_.reduce` and `_.reduceRight` without support |
| * for callback shorthands and `this` binding, which iterates over `collection` |
| * using the provided `eachFunc`. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {*} accumulator The initial value. |
| * @param {boolean} initFromCollection Specify using the first or last element |
| * of `collection` as the initial value. |
| * @param {Function} eachFunc The function to iterate over `collection`. |
| * @returns {*} Returns the accumulated value. |
| */ |
| function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) { |
| eachFunc(collection, function (value, index, collection) { |
| accumulator = initFromCollection ? (initFromCollection = false, value) : iteratee(accumulator, value, index, collection); |
| }); |
| return accumulator; |
| } |
| /** |
| * The base implementation of `setData` without support for hot loop detection. |
| * |
| * @private |
| * @param {Function} func The function to associate metadata with. |
| * @param {*} data The metadata. |
| * @returns {Function} Returns `func`. |
| */ |
| var baseSetData = !metaMap ? identity : function (func, data) { |
| metaMap.set(func, data); |
| return func; |
| }; |
| /** |
| * The base implementation of `_.slice` without an iteratee call guard. |
| * |
| * @private |
| * @param {Array} array The array to slice. |
| * @param {number} [start=0] The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns the slice of `array`. |
| */ |
| function baseSlice(array, start, end) { |
| var index = -1, length = array.length; |
| start = start == null ? 0 : +start || 0; |
| if (start < 0) { |
| start = -start > length ? 0 : length + start; |
| } |
| end = end === undefined || end > length ? length : +end || 0; |
| if (end < 0) { |
| end += length; |
| } |
| length = start > end ? 0 : end - start >>> 0; |
| start >>>= 0; |
| var result = Array(length); |
| while (++index < length) { |
| result[index] = array[index + start]; |
| } |
| return result; |
| } |
| /** |
| * The base implementation of `_.some` without support for callback shorthands |
| * and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {boolean} Returns `true` if any element passes the predicate check, |
| * else `false`. |
| */ |
| function baseSome(collection, predicate) { |
| var result; |
| baseEach(collection, function (value, index, collection) { |
| result = predicate(value, index, collection); |
| return !result; |
| }); |
| return !!result; |
| } |
| /** |
| * The base implementation of `_.sortBy` which uses `comparer` to define |
| * the sort order of `array` and replaces criteria objects with their |
| * corresponding values. |
| * |
| * @private |
| * @param {Array} array The array to sort. |
| * @param {Function} comparer The function to define sort order. |
| * @returns {Array} Returns `array`. |
| */ |
| function baseSortBy(array, comparer) { |
| var length = array.length; |
| array.sort(comparer); |
| while (length--) { |
| array[length] = array[length].value; |
| } |
| return array; |
| } |
| /** |
| * The base implementation of `_.sortByOrder` without param guards. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. |
| * @param {boolean[]} orders The sort orders of `iteratees`. |
| * @returns {Array} Returns the new sorted array. |
| */ |
| function baseSortByOrder(collection, iteratees, orders) { |
| var callback = getCallback(), index = -1; |
| iteratees = arrayMap(iteratees, function (iteratee) { |
| return callback(iteratee); |
| }); |
| var result = baseMap(collection, function (value) { |
| var criteria = arrayMap(iteratees, function (iteratee) { |
| return iteratee(value); |
| }); |
| return { |
| 'criteria': criteria, |
| 'index': ++index, |
| 'value': value |
| }; |
| }); |
| return baseSortBy(result, function (object, other) { |
| return compareMultiple(object, other, orders); |
| }); |
| } |
| /** |
| * The base implementation of `_.sum` without support for callback shorthands |
| * and `this` binding. |
| * |
| * @private |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @returns {number} Returns the sum. |
| */ |
| function baseSum(collection, iteratee) { |
| var result = 0; |
| baseEach(collection, function (value, index, collection) { |
| result += +iteratee(value, index, collection) || 0; |
| }); |
| return result; |
| } |
| /** |
| * The base implementation of `_.uniq` without support for callback shorthands |
| * and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to inspect. |
| * @param {Function} [iteratee] The function invoked per iteration. |
| * @returns {Array} Returns the new duplicate free array. |
| */ |
| function baseUniq(array, iteratee) { |
| var index = -1, indexOf = getIndexOf(), length = array.length, isCommon = indexOf === baseIndexOf, isLarge = isCommon && length >= LARGE_ARRAY_SIZE, seen = isLarge ? createCache() : null, result = []; |
| if (seen) { |
| indexOf = cacheIndexOf; |
| isCommon = false; |
| } else { |
| isLarge = false; |
| seen = iteratee ? [] : result; |
| } |
| outer: |
| while (++index < length) { |
| var value = array[index], computed = iteratee ? iteratee(value, index, array) : value; |
| if (isCommon && value === value) { |
| var seenIndex = seen.length; |
| while (seenIndex--) { |
| if (seen[seenIndex] === computed) { |
| continue outer; |
| } |
| } |
| if (iteratee) { |
| seen.push(computed); |
| } |
| result.push(value); |
| } else if (indexOf(seen, computed, 0) < 0) { |
| if (iteratee || isLarge) { |
| seen.push(computed); |
| } |
| result.push(value); |
| } |
| } |
| return result; |
| } |
| /** |
| * The base implementation of `_.values` and `_.valuesIn` which creates an |
| * array of `object` property values corresponding to the property names |
| * of `props`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {Array} props The property names to get values for. |
| * @returns {Object} Returns the array of property values. |
| */ |
| function baseValues(object, props) { |
| var index = -1, length = props.length, result = Array(length); |
| while (++index < length) { |
| result[index] = object[props[index]]; |
| } |
| return result; |
| } |
| /** |
| * The base implementation of `_.dropRightWhile`, `_.dropWhile`, `_.takeRightWhile`, |
| * and `_.takeWhile` without support for callback shorthands and `this` binding. |
| * |
| * @private |
| * @param {Array} array The array to query. |
| * @param {Function} predicate The function invoked per iteration. |
| * @param {boolean} [isDrop] Specify dropping elements instead of taking them. |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Array} Returns the slice of `array`. |
| */ |
| function baseWhile(array, predicate, isDrop, fromRight) { |
| var length = array.length, index = fromRight ? length : -1; |
| while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) { |
| } |
| return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index); |
| } |
| /** |
| * The base implementation of `wrapperValue` which returns the result of |
| * performing a sequence of actions on the unwrapped `value`, where each |
| * successive action is supplied the return value of the previous. |
| * |
| * @private |
| * @param {*} value The unwrapped value. |
| * @param {Array} actions Actions to peform to resolve the unwrapped value. |
| * @returns {*} Returns the resolved value. |
| */ |
| function baseWrapperValue(value, actions) { |
| var result = value; |
| if (result instanceof LazyWrapper) { |
| result = result.value(); |
| } |
| var index = -1, length = actions.length; |
| while (++index < length) { |
| var action = actions[index]; |
| result = action.func.apply(action.thisArg, arrayPush([result], action.args)); |
| } |
| return result; |
| } |
| /** |
| * Performs a binary search of `array` to determine the index at which `value` |
| * should be inserted into `array` in order to maintain its sort order. |
| * |
| * @private |
| * @param {Array} array The sorted array to inspect. |
| * @param {*} value The value to evaluate. |
| * @param {boolean} [retHighest] Specify returning the highest qualified index. |
| * @returns {number} Returns the index at which `value` should be inserted |
| * into `array`. |
| */ |
| function binaryIndex(array, value, retHighest) { |
| var low = 0, high = array ? array.length : low; |
| if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { |
| while (low < high) { |
| var mid = low + high >>> 1, computed = array[mid]; |
| if ((retHighest ? computed <= value : computed < value) && computed !== null) { |
| low = mid + 1; |
| } else { |
| high = mid; |
| } |
| } |
| return high; |
| } |
| return binaryIndexBy(array, value, identity, retHighest); |
| } |
| /** |
| * This function is like `binaryIndex` except that it invokes `iteratee` for |
| * `value` and each element of `array` to compute their sort ranking. The |
| * iteratee is invoked with one argument; (value). |
| * |
| * @private |
| * @param {Array} array The sorted array to inspect. |
| * @param {*} value The value to evaluate. |
| * @param {Function} iteratee The function invoked per iteration. |
| * @param {boolean} [retHighest] Specify returning the highest qualified index. |
| * @returns {number} Returns the index at which `value` should be inserted |
| * into `array`. |
| */ |
| function binaryIndexBy(array, value, iteratee, retHighest) { |
| value = iteratee(value); |
| var low = 0, high = array ? array.length : 0, valIsNaN = value !== value, valIsNull = value === null, valIsUndef = value === undefined; |
| while (low < high) { |
| var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), isDef = computed !== undefined, isReflexive = computed === computed; |
| if (valIsNaN) { |
| var setLow = isReflexive || retHighest; |
| } else if (valIsNull) { |
| setLow = isReflexive && isDef && (retHighest || computed != null); |
| } else if (valIsUndef) { |
| setLow = isReflexive && (retHighest || isDef); |
| } else if (computed == null) { |
| setLow = false; |
| } else { |
| setLow = retHighest ? computed <= value : computed < value; |
| } |
| if (setLow) { |
| low = mid + 1; |
| } else { |
| high = mid; |
| } |
| } |
| return nativeMin(high, MAX_ARRAY_INDEX); |
| } |
| /** |
| * A specialized version of `baseCallback` which only supports `this` binding |
| * and specifying the number of arguments to provide to `func`. |
| * |
| * @private |
| * @param {Function} func The function to bind. |
| * @param {*} thisArg The `this` binding of `func`. |
| * @param {number} [argCount] The number of arguments to provide to `func`. |
| * @returns {Function} Returns the callback. |
| */ |
| function bindCallback(func, thisArg, argCount) { |
| if (typeof func != 'function') { |
| return identity; |
| } |
| if (thisArg === undefined) { |
| return func; |
| } |
| switch (argCount) { |
| case 1: |
| return function (value) { |
| return func.call(thisArg, value); |
| }; |
| case 3: |
| return function (value, index, collection) { |
| return func.call(thisArg, value, index, collection); |
| }; |
| case 4: |
| return function (accumulator, value, index, collection) { |
| return func.call(thisArg, accumulator, value, index, collection); |
| }; |
| case 5: |
| return function (value, other, key, object, source) { |
| return func.call(thisArg, value, other, key, object, source); |
| }; |
| } |
| return function () { |
| return func.apply(thisArg, arguments); |
| }; |
| } |
| /** |
| * Creates a clone of the given array buffer. |
| * |
| * @private |
| * @param {ArrayBuffer} buffer The array buffer to clone. |
| * @returns {ArrayBuffer} Returns the cloned array buffer. |
| */ |
| function bufferClone(buffer) { |
| var result = new ArrayBuffer(buffer.byteLength), view = new Uint8Array(result); |
| view.set(new Uint8Array(buffer)); |
| return result; |
| } |
| /** |
| * Creates an array that is the composition of partially applied arguments, |
| * placeholders, and provided arguments into a single array of arguments. |
| * |
| * @private |
| * @param {Array|Object} args The provided arguments. |
| * @param {Array} partials The arguments to prepend to those provided. |
| * @param {Array} holders The `partials` placeholder indexes. |
| * @returns {Array} Returns the new array of composed arguments. |
| */ |
| function composeArgs(args, partials, holders) { |
| var holdersLength = holders.length, argsIndex = -1, argsLength = nativeMax(args.length - holdersLength, 0), leftIndex = -1, leftLength = partials.length, result = Array(leftLength + argsLength); |
| while (++leftIndex < leftLength) { |
| result[leftIndex] = partials[leftIndex]; |
| } |
| while (++argsIndex < holdersLength) { |
| result[holders[argsIndex]] = args[argsIndex]; |
| } |
| while (argsLength--) { |
| result[leftIndex++] = args[argsIndex++]; |
| } |
| return result; |
| } |
| /** |
| * This function is like `composeArgs` except that the arguments composition |
| * is tailored for `_.partialRight`. |
| * |
| * @private |
| * @param {Array|Object} args The provided arguments. |
| * @param {Array} partials The arguments to append to those provided. |
| * @param {Array} holders The `partials` placeholder indexes. |
| * @returns {Array} Returns the new array of composed arguments. |
| */ |
| function composeArgsRight(args, partials, holders) { |
| var holdersIndex = -1, holdersLength = holders.length, argsIndex = -1, argsLength = nativeMax(args.length - holdersLength, 0), rightIndex = -1, rightLength = partials.length, result = Array(argsLength + rightLength); |
| while (++argsIndex < argsLength) { |
| result[argsIndex] = args[argsIndex]; |
| } |
| var offset = argsIndex; |
| while (++rightIndex < rightLength) { |
| result[offset + rightIndex] = partials[rightIndex]; |
| } |
| while (++holdersIndex < holdersLength) { |
| result[offset + holders[holdersIndex]] = args[argsIndex++]; |
| } |
| return result; |
| } |
| /** |
| * Creates a `_.countBy`, `_.groupBy`, `_.indexBy`, or `_.partition` function. |
| * |
| * @private |
| * @param {Function} setter The function to set keys and values of the accumulator object. |
| * @param {Function} [initializer] The function to initialize the accumulator object. |
| * @returns {Function} Returns the new aggregator function. |
| */ |
| function createAggregator(setter, initializer) { |
| return function (collection, iteratee, thisArg) { |
| var result = initializer ? initializer() : {}; |
| iteratee = getCallback(iteratee, thisArg, 3); |
| if (isArray(collection)) { |
| var index = -1, length = collection.length; |
| while (++index < length) { |
| var value = collection[index]; |
| setter(result, value, iteratee(value, index, collection), collection); |
| } |
| } else { |
| baseEach(collection, function (value, key, collection) { |
| setter(result, value, iteratee(value, key, collection), collection); |
| }); |
| } |
| return result; |
| }; |
| } |
| /** |
| * Creates a `_.assign`, `_.defaults`, or `_.merge` function. |
| * |
| * @private |
| * @param {Function} assigner The function to assign values. |
| * @returns {Function} Returns the new assigner function. |
| */ |
| function createAssigner(assigner) { |
| return restParam(function (object, sources) { |
| var index = -1, length = object == null ? 0 : sources.length, customizer = length > 2 ? sources[length - 2] : undefined, guard = length > 2 ? sources[2] : undefined, thisArg = length > 1 ? sources[length - 1] : undefined; |
| if (typeof customizer == 'function') { |
| customizer = bindCallback(customizer, thisArg, 5); |
| length -= 2; |
| } else { |
| customizer = typeof thisArg == 'function' ? thisArg : undefined; |
| length -= customizer ? 1 : 0; |
| } |
| if (guard && isIterateeCall(sources[0], sources[1], guard)) { |
| customizer = length < 3 ? undefined : customizer; |
| length = 1; |
| } |
| while (++index < length) { |
| var source = sources[index]; |
| if (source) { |
| assigner(object, source, customizer); |
| } |
| } |
| return object; |
| }); |
| } |
| /** |
| * Creates a `baseEach` or `baseEachRight` function. |
| * |
| * @private |
| * @param {Function} eachFunc The function to iterate over a collection. |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new base function. |
| */ |
| function createBaseEach(eachFunc, fromRight) { |
| return function (collection, iteratee) { |
| var length = collection ? getLength(collection) : 0; |
| if (!isLength(length)) { |
| return eachFunc(collection, iteratee); |
| } |
| var index = fromRight ? length : -1, iterable = toObject(collection); |
| while (fromRight ? index-- : ++index < length) { |
| if (iteratee(iterable[index], index, iterable) === false) { |
| break; |
| } |
| } |
| return collection; |
| }; |
| } |
| /** |
| * Creates a base function for `_.forIn` or `_.forInRight`. |
| * |
| * @private |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new base function. |
| */ |
| function createBaseFor(fromRight) { |
| return function (object, iteratee, keysFunc) { |
| var iterable = toObject(object), props = keysFunc(object), length = props.length, index = fromRight ? length : -1; |
| while (fromRight ? index-- : ++index < length) { |
| var key = props[index]; |
| if (iteratee(iterable[key], key, iterable) === false) { |
| break; |
| } |
| } |
| return object; |
| }; |
| } |
| /** |
| * Creates a function that wraps `func` and invokes it with the `this` |
| * binding of `thisArg`. |
| * |
| * @private |
| * @param {Function} func The function to bind. |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @returns {Function} Returns the new bound function. |
| */ |
| function createBindWrapper(func, thisArg) { |
| var Ctor = createCtorWrapper(func); |
| function wrapper() { |
| var fn = this && this !== root && this instanceof wrapper ? Ctor : func; |
| return fn.apply(thisArg, arguments); |
| } |
| return wrapper; |
| } |
| /** |
| * Creates a `Set` cache object to optimize linear searches of large arrays. |
| * |
| * @private |
| * @param {Array} [values] The values to cache. |
| * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`. |
| */ |
| function createCache(values) { |
| return nativeCreate && Set ? new SetCache(values) : null; |
| } |
| /** |
| * Creates a function that produces compound words out of the words in a |
| * given string. |
| * |
| * @private |
| * @param {Function} callback The function to combine each word. |
| * @returns {Function} Returns the new compounder function. |
| */ |
| function createCompounder(callback) { |
| return function (string) { |
| var index = -1, array = words(deburr(string)), length = array.length, result = ''; |
| while (++index < length) { |
| result = callback(result, array[index], index); |
| } |
| return result; |
| }; |
| } |
| /** |
| * Creates a function that produces an instance of `Ctor` regardless of |
| * whether it was invoked as part of a `new` expression or by `call` or `apply`. |
| * |
| * @private |
| * @param {Function} Ctor The constructor to wrap. |
| * @returns {Function} Returns the new wrapped function. |
| */ |
| function createCtorWrapper(Ctor) { |
| return function () { |
| // Use a `switch` statement to work with class constructors. |
| // See http://ecma-international.org/ecma-262/6.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist |
| // for more details. |
| var args = arguments; |
| switch (args.length) { |
| case 0: |
| return new Ctor(); |
| case 1: |
| return new Ctor(args[0]); |
| case 2: |
| return new Ctor(args[0], args[1]); |
| case 3: |
| return new Ctor(args[0], args[1], args[2]); |
| case 4: |
| return new Ctor(args[0], args[1], args[2], args[3]); |
| case 5: |
| return new Ctor(args[0], args[1], args[2], args[3], args[4]); |
| case 6: |
| return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); |
| case 7: |
| return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); |
| } |
| var thisBinding = baseCreate(Ctor.prototype), result = Ctor.apply(thisBinding, args); |
| // Mimic the constructor's `return` behavior. |
| // See https://es5.github.io/#x13.2.2 for more details. |
| return isObject(result) ? result : thisBinding; |
| }; |
| } |
| /** |
| * Creates a `_.curry` or `_.curryRight` function. |
| * |
| * @private |
| * @param {boolean} flag The curry bit flag. |
| * @returns {Function} Returns the new curry function. |
| */ |
| function createCurry(flag) { |
| function curryFunc(func, arity, guard) { |
| if (guard && isIterateeCall(func, arity, guard)) { |
| arity = undefined; |
| } |
| var result = createWrapper(func, flag, undefined, undefined, undefined, undefined, undefined, arity); |
| result.placeholder = curryFunc.placeholder; |
| return result; |
| } |
| return curryFunc; |
| } |
| /** |
| * Creates a `_.defaults` or `_.defaultsDeep` function. |
| * |
| * @private |
| * @param {Function} assigner The function to assign values. |
| * @param {Function} customizer The function to customize assigned values. |
| * @returns {Function} Returns the new defaults function. |
| */ |
| function createDefaults(assigner, customizer) { |
| return restParam(function (args) { |
| var object = args[0]; |
| if (object == null) { |
| return object; |
| } |
| args.push(customizer); |
| return assigner.apply(undefined, args); |
| }); |
| } |
| /** |
| * Creates a `_.max` or `_.min` function. |
| * |
| * @private |
| * @param {Function} comparator The function used to compare values. |
| * @param {*} exValue The initial extremum value. |
| * @returns {Function} Returns the new extremum function. |
| */ |
| function createExtremum(comparator, exValue) { |
| return function (collection, iteratee, thisArg) { |
| if (thisArg && isIterateeCall(collection, iteratee, thisArg)) { |
| iteratee = undefined; |
| } |
| iteratee = getCallback(iteratee, thisArg, 3); |
| if (iteratee.length == 1) { |
| collection = isArray(collection) ? collection : toIterable(collection); |
| var result = arrayExtremum(collection, iteratee, comparator, exValue); |
| if (!(collection.length && result === exValue)) { |
| return result; |
| } |
| } |
| return baseExtremum(collection, iteratee, comparator, exValue); |
| }; |
| } |
| /** |
| * Creates a `_.find` or `_.findLast` function. |
| * |
| * @private |
| * @param {Function} eachFunc The function to iterate over a collection. |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new find function. |
| */ |
| function createFind(eachFunc, fromRight) { |
| return function (collection, predicate, thisArg) { |
| predicate = getCallback(predicate, thisArg, 3); |
| if (isArray(collection)) { |
| var index = baseFindIndex(collection, predicate, fromRight); |
| return index > -1 ? collection[index] : undefined; |
| } |
| return baseFind(collection, predicate, eachFunc); |
| }; |
| } |
| /** |
| * Creates a `_.findIndex` or `_.findLastIndex` function. |
| * |
| * @private |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new find function. |
| */ |
| function createFindIndex(fromRight) { |
| return function (array, predicate, thisArg) { |
| if (!(array && array.length)) { |
| return -1; |
| } |
| predicate = getCallback(predicate, thisArg, 3); |
| return baseFindIndex(array, predicate, fromRight); |
| }; |
| } |
| /** |
| * Creates a `_.findKey` or `_.findLastKey` function. |
| * |
| * @private |
| * @param {Function} objectFunc The function to iterate over an object. |
| * @returns {Function} Returns the new find function. |
| */ |
| function createFindKey(objectFunc) { |
| return function (object, predicate, thisArg) { |
| predicate = getCallback(predicate, thisArg, 3); |
| return baseFind(object, predicate, objectFunc, true); |
| }; |
| } |
| /** |
| * Creates a `_.flow` or `_.flowRight` function. |
| * |
| * @private |
| * @param {boolean} [fromRight] Specify iterating from right to left. |
| * @returns {Function} Returns the new flow function. |
| */ |
| function createFlow(fromRight) { |
| return function () { |
| var wrapper, length = arguments.length, index = fromRight ? length : -1, leftIndex = 0, funcs = Array(length); |
| while (fromRight ? index-- : ++index < length) { |
| var func = funcs[leftIndex++] = arguments[index]; |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| if (!wrapper && LodashWrapper.prototype.thru && getFuncName(func) == 'wrapper') { |
| wrapper = new LodashWrapper([], true); |
| } |
| } |
| index = wrapper ? -1 : length; |
| while (++index < length) { |
| func = funcs[index]; |
| var funcName = getFuncName(func), data = funcName == 'wrapper' ? getData(func) : undefined; |
| if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) { |
| wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); |
| } else { |
| wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func); |
| } |
| } |
| return function () { |
| var args = arguments, value = args[0]; |
| if (wrapper && args.length == 1 && isArray(value) && value.length >= LARGE_ARRAY_SIZE) { |
| return wrapper.plant(value).value(); |
| } |
| var index = 0, result = length ? funcs[index].apply(this, args) : value; |
| while (++index < length) { |
| result = funcs[index].call(this, result); |
| } |
| return result; |
| }; |
| }; |
| } |
| /** |
| * Creates a function for `_.forEach` or `_.forEachRight`. |
| * |
| * @private |
| * @param {Function} arrayFunc The function to iterate over an array. |
| * @param {Function} eachFunc The function to iterate over a collection. |
| * @returns {Function} Returns the new each function. |
| */ |
| function createForEach(arrayFunc, eachFunc) { |
| return function (collection, iteratee, thisArg) { |
| return typeof iteratee == 'function' && thisArg === undefined && isArray(collection) ? arrayFunc(collection, iteratee) : eachFunc(collection, bindCallback(iteratee, thisArg, 3)); |
| }; |
| } |
| /** |
| * Creates a function for `_.forIn` or `_.forInRight`. |
| * |
| * @private |
| * @param {Function} objectFunc The function to iterate over an object. |
| * @returns {Function} Returns the new each function. |
| */ |
| function createForIn(objectFunc) { |
| return function (object, iteratee, thisArg) { |
| if (typeof iteratee != 'function' || thisArg !== undefined) { |
| iteratee = bindCallback(iteratee, thisArg, 3); |
| } |
| return objectFunc(object, iteratee, keysIn); |
| }; |
| } |
| /** |
| * Creates a function for `_.forOwn` or `_.forOwnRight`. |
| * |
| * @private |
| * @param {Function} objectFunc The function to iterate over an object. |
| * @returns {Function} Returns the new each function. |
| */ |
| function createForOwn(objectFunc) { |
| return function (object, iteratee, thisArg) { |
| if (typeof iteratee != 'function' || thisArg !== undefined) { |
| iteratee = bindCallback(iteratee, thisArg, 3); |
| } |
| return objectFunc(object, iteratee); |
| }; |
| } |
| /** |
| * Creates a function for `_.mapKeys` or `_.mapValues`. |
| * |
| * @private |
| * @param {boolean} [isMapKeys] Specify mapping keys instead of values. |
| * @returns {Function} Returns the new map function. |
| */ |
| function createObjectMapper(isMapKeys) { |
| return function (object, iteratee, thisArg) { |
| var result = {}; |
| iteratee = getCallback(iteratee, thisArg, 3); |
| baseForOwn(object, function (value, key, object) { |
| var mapped = iteratee(value, key, object); |
| key = isMapKeys ? mapped : key; |
| value = isMapKeys ? value : mapped; |
| result[key] = value; |
| }); |
| return result; |
| }; |
| } |
| /** |
| * Creates a function for `_.padLeft` or `_.padRight`. |
| * |
| * @private |
| * @param {boolean} [fromRight] Specify padding from the right. |
| * @returns {Function} Returns the new pad function. |
| */ |
| function createPadDir(fromRight) { |
| return function (string, length, chars) { |
| string = baseToString(string); |
| return (fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string); |
| }; |
| } |
| /** |
| * Creates a `_.partial` or `_.partialRight` function. |
| * |
| * @private |
| * @param {boolean} flag The partial bit flag. |
| * @returns {Function} Returns the new partial function. |
| */ |
| function createPartial(flag) { |
| var partialFunc = restParam(function (func, partials) { |
| var holders = replaceHolders(partials, partialFunc.placeholder); |
| return createWrapper(func, flag, undefined, partials, holders); |
| }); |
| return partialFunc; |
| } |
| /** |
| * Creates a function for `_.reduce` or `_.reduceRight`. |
| * |
| * @private |
| * @param {Function} arrayFunc The function to iterate over an array. |
| * @param {Function} eachFunc The function to iterate over a collection. |
| * @returns {Function} Returns the new each function. |
| */ |
| function createReduce(arrayFunc, eachFunc) { |
| return function (collection, iteratee, accumulator, thisArg) { |
| var initFromArray = arguments.length < 3; |
| return typeof iteratee == 'function' && thisArg === undefined && isArray(collection) ? arrayFunc(collection, iteratee, accumulator, initFromArray) : baseReduce(collection, getCallback(iteratee, thisArg, 4), accumulator, initFromArray, eachFunc); |
| }; |
| } |
| /** |
| * Creates a function that wraps `func` and invokes it with optional `this` |
| * binding of, partial application, and currying. |
| * |
| * @private |
| * @param {Function|string} func The function or method name to reference. |
| * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details. |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @param {Array} [partials] The arguments to prepend to those provided to the new function. |
| * @param {Array} [holders] The `partials` placeholder indexes. |
| * @param {Array} [partialsRight] The arguments to append to those provided to the new function. |
| * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. |
| * @param {Array} [argPos] The argument positions of the new function. |
| * @param {number} [ary] The arity cap of `func`. |
| * @param {number} [arity] The arity of `func`. |
| * @returns {Function} Returns the new wrapped function. |
| */ |
| function createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { |
| var isAry = bitmask & ARY_FLAG, isBind = bitmask & BIND_FLAG, isBindKey = bitmask & BIND_KEY_FLAG, isCurry = bitmask & CURRY_FLAG, isCurryBound = bitmask & CURRY_BOUND_FLAG, isCurryRight = bitmask & CURRY_RIGHT_FLAG, Ctor = isBindKey ? undefined : createCtorWrapper(func); |
| function wrapper() { |
| // Avoid `arguments` object use disqualifying optimizations by |
| // converting it to an array before providing it to other functions. |
| var length = arguments.length, index = length, args = Array(length); |
| while (index--) { |
| args[index] = arguments[index]; |
| } |
| if (partials) { |
| args = composeArgs(args, partials, holders); |
| } |
| if (partialsRight) { |
| args = composeArgsRight(args, partialsRight, holdersRight); |
| } |
| if (isCurry || isCurryRight) { |
| var placeholder = wrapper.placeholder, argsHolders = replaceHolders(args, placeholder); |
| length -= argsHolders.length; |
| if (length < arity) { |
| var newArgPos = argPos ? arrayCopy(argPos) : undefined, newArity = nativeMax(arity - length, 0), newsHolders = isCurry ? argsHolders : undefined, newHoldersRight = isCurry ? undefined : argsHolders, newPartials = isCurry ? args : undefined, newPartialsRight = isCurry ? undefined : args; |
| bitmask |= isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG; |
| bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG); |
| if (!isCurryBound) { |
| bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG); |
| } |
| var newData = [ |
| func, |
| bitmask, |
| thisArg, |
| newPartials, |
| newsHolders, |
| newPartialsRight, |
| newHoldersRight, |
| newArgPos, |
| ary, |
| newArity |
| ], result = createHybridWrapper.apply(undefined, newData); |
| if (isLaziable(func)) { |
| setData(result, newData); |
| } |
| result.placeholder = placeholder; |
| return result; |
| } |
| } |
| var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func; |
| if (argPos) { |
| args = reorder(args, argPos); |
| } |
| if (isAry && ary < args.length) { |
| args.length = ary; |
| } |
| if (this && this !== root && this instanceof wrapper) { |
| fn = Ctor || createCtorWrapper(func); |
| } |
| return fn.apply(thisBinding, args); |
| } |
| return wrapper; |
| } |
| /** |
| * Creates the padding required for `string` based on the given `length`. |
| * The `chars` string is truncated if the number of characters exceeds `length`. |
| * |
| * @private |
| * @param {string} string The string to create padding for. |
| * @param {number} [length=0] The padding length. |
| * @param {string} [chars=' '] The string used as padding. |
| * @returns {string} Returns the pad for `string`. |
| */ |
| function createPadding(string, length, chars) { |
| var strLength = string.length; |
| length = +length; |
| if (strLength >= length || !nativeIsFinite(length)) { |
| return ''; |
| } |
| var padLength = length - strLength; |
| chars = chars == null ? ' ' : chars + ''; |
| return repeat(chars, nativeCeil(padLength / chars.length)).slice(0, padLength); |
| } |
| /** |
| * Creates a function that wraps `func` and invokes it with the optional `this` |
| * binding of `thisArg` and the `partials` prepended to those provided to |
| * the wrapper. |
| * |
| * @private |
| * @param {Function} func The function to partially apply arguments to. |
| * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details. |
| * @param {*} thisArg The `this` binding of `func`. |
| * @param {Array} partials The arguments to prepend to those provided to the new function. |
| * @returns {Function} Returns the new bound function. |
| */ |
| function createPartialWrapper(func, bitmask, thisArg, partials) { |
| var isBind = bitmask & BIND_FLAG, Ctor = createCtorWrapper(func); |
| function wrapper() { |
| // Avoid `arguments` object use disqualifying optimizations by |
| // converting it to an array before providing it `func`. |
| var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength); |
| while (++leftIndex < leftLength) { |
| args[leftIndex] = partials[leftIndex]; |
| } |
| while (argsLength--) { |
| args[leftIndex++] = arguments[++argsIndex]; |
| } |
| var fn = this && this !== root && this instanceof wrapper ? Ctor : func; |
| return fn.apply(isBind ? thisArg : this, args); |
| } |
| return wrapper; |
| } |
| /** |
| * Creates a `_.ceil`, `_.floor`, or `_.round` function. |
| * |
| * @private |
| * @param {string} methodName The name of the `Math` method to use when rounding. |
| * @returns {Function} Returns the new round function. |
| */ |
| function createRound(methodName) { |
| var func = Math[methodName]; |
| return function (number, precision) { |
| precision = precision === undefined ? 0 : +precision || 0; |
| if (precision) { |
| precision = pow(10, precision); |
| return func(number * precision) / precision; |
| } |
| return func(number); |
| }; |
| } |
| /** |
| * Creates a `_.sortedIndex` or `_.sortedLastIndex` function. |
| * |
| * @private |
| * @param {boolean} [retHighest] Specify returning the highest qualified index. |
| * @returns {Function} Returns the new index function. |
| */ |
| function createSortedIndex(retHighest) { |
| return function (array, value, iteratee, thisArg) { |
| var callback = getCallback(iteratee); |
| return iteratee == null && callback === baseCallback ? binaryIndex(array, value, retHighest) : binaryIndexBy(array, value, callback(iteratee, thisArg, 1), retHighest); |
| }; |
| } |
| /** |
| * Creates a function that either curries or invokes `func` with optional |
| * `this` binding and partially applied arguments. |
| * |
| * @private |
| * @param {Function|string} func The function or method name to reference. |
| * @param {number} bitmask The bitmask of flags. |
| * The bitmask may be composed of the following flags: |
| * 1 - `_.bind` |
| * 2 - `_.bindKey` |
| * 4 - `_.curry` or `_.curryRight` of a bound function |
| * 8 - `_.curry` |
| * 16 - `_.curryRight` |
| * 32 - `_.partial` |
| * 64 - `_.partialRight` |
| * 128 - `_.rearg` |
| * 256 - `_.ary` |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @param {Array} [partials] The arguments to be partially applied. |
| * @param {Array} [holders] The `partials` placeholder indexes. |
| * @param {Array} [argPos] The argument positions of the new function. |
| * @param {number} [ary] The arity cap of `func`. |
| * @param {number} [arity] The arity of `func`. |
| * @returns {Function} Returns the new wrapped function. |
| */ |
| function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { |
| var isBindKey = bitmask & BIND_KEY_FLAG; |
| if (!isBindKey && typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| var length = partials ? partials.length : 0; |
| if (!length) { |
| bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG); |
| partials = holders = undefined; |
| } |
| length -= holders ? holders.length : 0; |
| if (bitmask & PARTIAL_RIGHT_FLAG) { |
| var partialsRight = partials, holdersRight = holders; |
| partials = holders = undefined; |
| } |
| var data = isBindKey ? undefined : getData(func), newData = [ |
| func, |
| bitmask, |
| thisArg, |
| partials, |
| holders, |
| partialsRight, |
| holdersRight, |
| argPos, |
| ary, |
| arity |
| ]; |
| if (data) { |
| mergeData(newData, data); |
| bitmask = newData[1]; |
| arity = newData[9]; |
| } |
| newData[9] = arity == null ? isBindKey ? 0 : func.length : nativeMax(arity - length, 0) || 0; |
| if (bitmask == BIND_FLAG) { |
| var result = createBindWrapper(newData[0], newData[2]); |
| } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !newData[4].length) { |
| result = createPartialWrapper.apply(undefined, newData); |
| } else { |
| result = createHybridWrapper.apply(undefined, newData); |
| } |
| var setter = data ? baseSetData : setData; |
| return setter(result, newData); |
| } |
| /** |
| * A specialized version of `baseIsEqualDeep` for arrays with support for |
| * partial deep comparisons. |
| * |
| * @private |
| * @param {Array} array The array to compare. |
| * @param {Array} other The other array to compare. |
| * @param {Function} equalFunc The function to determine equivalents of values. |
| * @param {Function} [customizer] The function to customize comparing arrays. |
| * @param {boolean} [isLoose] Specify performing partial comparisons. |
| * @param {Array} [stackA] Tracks traversed `value` objects. |
| * @param {Array} [stackB] Tracks traversed `other` objects. |
| * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. |
| */ |
| function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) { |
| var index = -1, arrLength = array.length, othLength = other.length; |
| if (arrLength != othLength && !(isLoose && othLength > arrLength)) { |
| return false; |
| } |
| // Ignore non-index properties. |
| while (++index < arrLength) { |
| var arrValue = array[index], othValue = other[index], result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined; |
| if (result !== undefined) { |
| if (result) { |
| continue; |
| } |
| return false; |
| } |
| // Recursively compare arrays (susceptible to call stack limits). |
| if (isLoose) { |
| if (!arraySome(other, function (othValue) { |
| return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB); |
| })) { |
| return false; |
| } |
| } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) { |
| return false; |
| } |
| } |
| return true; |
| } |
| /** |
| * A specialized version of `baseIsEqualDeep` for comparing objects of |
| * the same `toStringTag`. |
| * |
| * **Note:** This function only supports comparing values with tags of |
| * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. |
| * |
| * @private |
| * @param {Object} object The object to compare. |
| * @param {Object} other The other object to compare. |
| * @param {string} tag The `toStringTag` of the objects to compare. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function equalByTag(object, other, tag) { |
| switch (tag) { |
| case boolTag: |
| case dateTag: |
| // Coerce dates and booleans to numbers, dates to milliseconds and booleans |
| // to `1` or `0` treating invalid dates coerced to `NaN` as not equal. |
| return +object == +other; |
| case errorTag: |
| return object.name == other.name && object.message == other.message; |
| case numberTag: |
| // Treat `NaN` vs. `NaN` as equal. |
| return object != +object ? other != +other : object == +other; |
| case regexpTag: |
| case stringTag: |
| // Coerce regexes to strings and treat strings primitives and string |
| // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details. |
| return object == other + ''; |
| } |
| return false; |
| } |
| /** |
| * A specialized version of `baseIsEqualDeep` for objects with support for |
| * partial deep comparisons. |
| * |
| * @private |
| * @param {Object} object The object to compare. |
| * @param {Object} other The other object to compare. |
| * @param {Function} equalFunc The function to determine equivalents of values. |
| * @param {Function} [customizer] The function to customize comparing values. |
| * @param {boolean} [isLoose] Specify performing partial comparisons. |
| * @param {Array} [stackA] Tracks traversed `value` objects. |
| * @param {Array} [stackB] Tracks traversed `other` objects. |
| * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. |
| */ |
| function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) { |
| var objProps = keys(object), objLength = objProps.length, othProps = keys(other), othLength = othProps.length; |
| if (objLength != othLength && !isLoose) { |
| return false; |
| } |
| var index = objLength; |
| while (index--) { |
| var key = objProps[index]; |
| if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) { |
| return false; |
| } |
| } |
| var skipCtor = isLoose; |
| while (++index < objLength) { |
| key = objProps[index]; |
| var objValue = object[key], othValue = other[key], result = customizer ? customizer(isLoose ? othValue : objValue, isLoose ? objValue : othValue, key) : undefined; |
| // Recursively compare objects (susceptible to call stack limits). |
| if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) { |
| return false; |
| } |
| skipCtor || (skipCtor = key == 'constructor'); |
| } |
| if (!skipCtor) { |
| var objCtor = object.constructor, othCtor = other.constructor; |
| // Non `Object` object instances with different constructors are not equal. |
| if (objCtor != othCtor && ('constructor' in object && 'constructor' in other) && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| /** |
| * Gets the appropriate "callback" function. If the `_.callback` method is |
| * customized this function returns the custom method, otherwise it returns |
| * the `baseCallback` function. If arguments are provided the chosen function |
| * is invoked with them and its result is returned. |
| * |
| * @private |
| * @returns {Function} Returns the chosen function or its result. |
| */ |
| function getCallback(func, thisArg, argCount) { |
| var result = lodash.callback || callback; |
| result = result === callback ? baseCallback : result; |
| return argCount ? result(func, thisArg, argCount) : result; |
| } |
| /** |
| * Gets metadata for `func`. |
| * |
| * @private |
| * @param {Function} func The function to query. |
| * @returns {*} Returns the metadata for `func`. |
| */ |
| var getData = !metaMap ? noop : function (func) { |
| return metaMap.get(func); |
| }; |
| /** |
| * Gets the name of `func`. |
| * |
| * @private |
| * @param {Function} func The function to query. |
| * @returns {string} Returns the function name. |
| */ |
| function getFuncName(func) { |
| var result = func.name + '', array = realNames[result], length = array ? array.length : 0; |
| while (length--) { |
| var data = array[length], otherFunc = data.func; |
| if (otherFunc == null || otherFunc == func) { |
| return data.name; |
| } |
| } |
| return result; |
| } |
| /** |
| * Gets the appropriate "indexOf" function. If the `_.indexOf` method is |
| * customized this function returns the custom method, otherwise it returns |
| * the `baseIndexOf` function. If arguments are provided the chosen function |
| * is invoked with them and its result is returned. |
| * |
| * @private |
| * @returns {Function|number} Returns the chosen function or its result. |
| */ |
| function getIndexOf(collection, target, fromIndex) { |
| var result = lodash.indexOf || indexOf; |
| result = result === indexOf ? baseIndexOf : result; |
| return collection ? result(collection, target, fromIndex) : result; |
| } |
| /** |
| * Gets the "length" property value of `object`. |
| * |
| * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) |
| * that affects Safari on at least iOS 8.1-8.3 ARM64. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {*} Returns the "length" value. |
| */ |
| var getLength = baseProperty('length'); |
| /** |
| * Gets the propery names, values, and compare flags of `object`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the match data of `object`. |
| */ |
| function getMatchData(object) { |
| var result = pairs(object), length = result.length; |
| while (length--) { |
| result[length][2] = isStrictComparable(result[length][1]); |
| } |
| return result; |
| } |
| /** |
| * Gets the native function at `key` of `object`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {string} key The key of the method to get. |
| * @returns {*} Returns the function if it's native, else `undefined`. |
| */ |
| function getNative(object, key) { |
| var value = object == null ? undefined : object[key]; |
| return isNative(value) ? value : undefined; |
| } |
| /** |
| * Gets the view, applying any `transforms` to the `start` and `end` positions. |
| * |
| * @private |
| * @param {number} start The start of the view. |
| * @param {number} end The end of the view. |
| * @param {Array} transforms The transformations to apply to the view. |
| * @returns {Object} Returns an object containing the `start` and `end` |
| * positions of the view. |
| */ |
| function getView(start, end, transforms) { |
| var index = -1, length = transforms.length; |
| while (++index < length) { |
| var data = transforms[index], size = data.size; |
| switch (data.type) { |
| case 'drop': |
| start += size; |
| break; |
| case 'dropRight': |
| end -= size; |
| break; |
| case 'take': |
| end = nativeMin(end, start + size); |
| break; |
| case 'takeRight': |
| start = nativeMax(start, end - size); |
| break; |
| } |
| } |
| return { |
| 'start': start, |
| 'end': end |
| }; |
| } |
| /** |
| * Initializes an array clone. |
| * |
| * @private |
| * @param {Array} array The array to clone. |
| * @returns {Array} Returns the initialized clone. |
| */ |
| function initCloneArray(array) { |
| var length = array.length, result = new array.constructor(length); |
| // Add array properties assigned by `RegExp#exec`. |
| if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { |
| result.index = array.index; |
| result.input = array.input; |
| } |
| return result; |
| } |
| /** |
| * Initializes an object clone. |
| * |
| * @private |
| * @param {Object} object The object to clone. |
| * @returns {Object} Returns the initialized clone. |
| */ |
| function initCloneObject(object) { |
| var Ctor = object.constructor; |
| if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) { |
| Ctor = Object; |
| } |
| return new Ctor(); |
| } |
| /** |
| * Initializes an object clone based on its `toStringTag`. |
| * |
| * **Note:** This function only supports cloning values with tags of |
| * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. |
| * |
| * @private |
| * @param {Object} object The object to clone. |
| * @param {string} tag The `toStringTag` of the object to clone. |
| * @param {boolean} [isDeep] Specify a deep clone. |
| * @returns {Object} Returns the initialized clone. |
| */ |
| function initCloneByTag(object, tag, isDeep) { |
| var Ctor = object.constructor; |
| switch (tag) { |
| case arrayBufferTag: |
| return bufferClone(object); |
| case boolTag: |
| case dateTag: |
| return new Ctor(+object); |
| case float32Tag: |
| case float64Tag: |
| case int8Tag: |
| case int16Tag: |
| case int32Tag: |
| case uint8Tag: |
| case uint8ClampedTag: |
| case uint16Tag: |
| case uint32Tag: |
| var buffer = object.buffer; |
| return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length); |
| case numberTag: |
| case stringTag: |
| return new Ctor(object); |
| case regexpTag: |
| var result = new Ctor(object.source, reFlags.exec(object)); |
| result.lastIndex = object.lastIndex; |
| } |
| return result; |
| } |
| /** |
| * Invokes the method at `path` on `object`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path of the method to invoke. |
| * @param {Array} args The arguments to invoke the method with. |
| * @returns {*} Returns the result of the invoked method. |
| */ |
| function invokePath(object, path, args) { |
| if (object != null && !isKey(path, object)) { |
| path = toPath(path); |
| object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1)); |
| path = last(path); |
| } |
| var func = object == null ? object : object[path]; |
| return func == null ? undefined : func.apply(object, args); |
| } |
| /** |
| * Checks if `value` is array-like. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is array-like, else `false`. |
| */ |
| function isArrayLike(value) { |
| return value != null && isLength(getLength(value)); |
| } |
| /** |
| * Checks if `value` is a valid array-like index. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. |
| * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. |
| */ |
| function isIndex(value, length) { |
| value = typeof value == 'number' || reIsUint.test(value) ? +value : -1; |
| length = length == null ? MAX_SAFE_INTEGER : length; |
| return value > -1 && value % 1 == 0 && value < length; |
| } |
| /** |
| * Checks if the provided arguments are from an iteratee call. |
| * |
| * @private |
| * @param {*} value The potential iteratee value argument. |
| * @param {*} index The potential iteratee index or key argument. |
| * @param {*} object The potential iteratee object argument. |
| * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`. |
| */ |
| function isIterateeCall(value, index, object) { |
| if (!isObject(object)) { |
| return false; |
| } |
| var type = typeof index; |
| if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) { |
| var other = object[index]; |
| return value === value ? value === other : other !== other; |
| } |
| return false; |
| } |
| /** |
| * Checks if `value` is a property name and not a property path. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @param {Object} [object] The object to query keys on. |
| * @returns {boolean} Returns `true` if `value` is a property name, else `false`. |
| */ |
| function isKey(value, object) { |
| var type = typeof value; |
| if (type == 'string' && reIsPlainProp.test(value) || type == 'number') { |
| return true; |
| } |
| if (isArray(value)) { |
| return false; |
| } |
| var result = !reIsDeepProp.test(value); |
| return result || object != null && value in toObject(object); |
| } |
| /** |
| * Checks if `func` has a lazy counterpart. |
| * |
| * @private |
| * @param {Function} func The function to check. |
| * @returns {boolean} Returns `true` if `func` has a lazy counterpart, else `false`. |
| */ |
| function isLaziable(func) { |
| var funcName = getFuncName(func), other = lodash[funcName]; |
| if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { |
| return false; |
| } |
| if (func === other) { |
| return true; |
| } |
| var data = getData(other); |
| return !!data && func === data[0]; |
| } |
| /** |
| * Checks if `value` is a valid array-like length. |
| * |
| * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. |
| */ |
| function isLength(value) { |
| return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; |
| } |
| /** |
| * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. |
| * |
| * @private |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` if suitable for strict |
| * equality comparisons, else `false`. |
| */ |
| function isStrictComparable(value) { |
| return value === value && !isObject(value); |
| } |
| /** |
| * Merges the function metadata of `source` into `data`. |
| * |
| * Merging metadata reduces the number of wrappers required to invoke a function. |
| * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` |
| * may be applied regardless of execution order. Methods like `_.ary` and `_.rearg` |
| * augment function arguments, making the order in which they are executed important, |
| * preventing the merging of metadata. However, we make an exception for a safe |
| * common case where curried functions have `_.ary` and or `_.rearg` applied. |
| * |
| * @private |
| * @param {Array} data The destination metadata. |
| * @param {Array} source The source metadata. |
| * @returns {Array} Returns `data`. |
| */ |
| function mergeData(data, source) { |
| var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < ARY_FLAG; |
| var isCombo = srcBitmask == ARY_FLAG && bitmask == CURRY_FLAG || srcBitmask == ARY_FLAG && bitmask == REARG_FLAG && data[7].length <= source[8] || srcBitmask == (ARY_FLAG | REARG_FLAG) && bitmask == CURRY_FLAG; |
| // Exit early if metadata can't be merged. |
| if (!(isCommon || isCombo)) { |
| return data; |
| } |
| // Use source `thisArg` if available. |
| if (srcBitmask & BIND_FLAG) { |
| data[2] = source[2]; |
| // Set when currying a bound function. |
| newBitmask |= bitmask & BIND_FLAG ? 0 : CURRY_BOUND_FLAG; |
| } |
| // Compose partial arguments. |
| var value = source[3]; |
| if (value) { |
| var partials = data[3]; |
| data[3] = partials ? composeArgs(partials, value, source[4]) : arrayCopy(value); |
| data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : arrayCopy(source[4]); |
| } |
| // Compose partial right arguments. |
| value = source[5]; |
| if (value) { |
| partials = data[5]; |
| data[5] = partials ? composeArgsRight(partials, value, source[6]) : arrayCopy(value); |
| data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : arrayCopy(source[6]); |
| } |
| // Use source `argPos` if available. |
| value = source[7]; |
| if (value) { |
| data[7] = arrayCopy(value); |
| } |
| // Use source `ary` if it's smaller. |
| if (srcBitmask & ARY_FLAG) { |
| data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); |
| } |
| // Use source `arity` if one is not provided. |
| if (data[9] == null) { |
| data[9] = source[9]; |
| } |
| // Use source `func` and merge bitmasks. |
| data[0] = source[0]; |
| data[1] = newBitmask; |
| return data; |
| } |
| /** |
| * Used by `_.defaultsDeep` to customize its `_.merge` use. |
| * |
| * @private |
| * @param {*} objectValue The destination object property value. |
| * @param {*} sourceValue The source object property value. |
| * @returns {*} Returns the value to assign to the destination object. |
| */ |
| function mergeDefaults(objectValue, sourceValue) { |
| return objectValue === undefined ? sourceValue : merge(objectValue, sourceValue, mergeDefaults); |
| } |
| /** |
| * A specialized version of `_.pick` which picks `object` properties specified |
| * by `props`. |
| * |
| * @private |
| * @param {Object} object The source object. |
| * @param {string[]} props The property names to pick. |
| * @returns {Object} Returns the new object. |
| */ |
| function pickByArray(object, props) { |
| object = toObject(object); |
| var index = -1, length = props.length, result = {}; |
| while (++index < length) { |
| var key = props[index]; |
| if (key in object) { |
| result[key] = object[key]; |
| } |
| } |
| return result; |
| } |
| /** |
| * A specialized version of `_.pick` which picks `object` properties `predicate` |
| * returns truthy for. |
| * |
| * @private |
| * @param {Object} object The source object. |
| * @param {Function} predicate The function invoked per iteration. |
| * @returns {Object} Returns the new object. |
| */ |
| function pickByCallback(object, predicate) { |
| var result = {}; |
| baseForIn(object, function (value, key, object) { |
| if (predicate(value, key, object)) { |
| result[key] = value; |
| } |
| }); |
| return result; |
| } |
| /** |
| * Reorder `array` according to the specified indexes where the element at |
| * the first index is assigned as the first element, the element at |
| * the second index is assigned as the second element, and so on. |
| * |
| * @private |
| * @param {Array} array The array to reorder. |
| * @param {Array} indexes The arranged array indexes. |
| * @returns {Array} Returns `array`. |
| */ |
| function reorder(array, indexes) { |
| var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = arrayCopy(array); |
| while (length--) { |
| var index = indexes[length]; |
| array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined; |
| } |
| return array; |
| } |
| /** |
| * Sets metadata for `func`. |
| * |
| * **Note:** If this function becomes hot, i.e. is invoked a lot in a short |
| * period of time, it will trip its breaker and transition to an identity function |
| * to avoid garbage collection pauses in V8. See [V8 issue 2070](https://code.google.com/p/v8/issues/detail?id=2070) |
| * for more details. |
| * |
| * @private |
| * @param {Function} func The function to associate metadata with. |
| * @param {*} data The metadata. |
| * @returns {Function} Returns `func`. |
| */ |
| var setData = function () { |
| var count = 0, lastCalled = 0; |
| return function (key, value) { |
| var stamp = now(), remaining = HOT_SPAN - (stamp - lastCalled); |
| lastCalled = stamp; |
| if (remaining > 0) { |
| if (++count >= HOT_COUNT) { |
| return key; |
| } |
| } else { |
| count = 0; |
| } |
| return baseSetData(key, value); |
| }; |
| }(); |
| /** |
| * A fallback implementation of `Object.keys` which creates an array of the |
| * own enumerable property names of `object`. |
| * |
| * @private |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| */ |
| function shimKeys(object) { |
| var props = keysIn(object), propsLength = props.length, length = propsLength && object.length; |
| var allowIndexes = !!length && isLength(length) && (isArray(object) || isArguments(object)); |
| var index = -1, result = []; |
| while (++index < propsLength) { |
| var key = props[index]; |
| if (allowIndexes && isIndex(key, length) || hasOwnProperty.call(object, key)) { |
| result.push(key); |
| } |
| } |
| return result; |
| } |
| /** |
| * Converts `value` to an array-like object if it's not one. |
| * |
| * @private |
| * @param {*} value The value to process. |
| * @returns {Array|Object} Returns the array-like object. |
| */ |
| function toIterable(value) { |
| if (value == null) { |
| return []; |
| } |
| if (!isArrayLike(value)) { |
| return values(value); |
| } |
| return isObject(value) ? value : Object(value); |
| } |
| /** |
| * Converts `value` to an object if it's not one. |
| * |
| * @private |
| * @param {*} value The value to process. |
| * @returns {Object} Returns the object. |
| */ |
| function toObject(value) { |
| return isObject(value) ? value : Object(value); |
| } |
| /** |
| * Converts `value` to property path array if it's not one. |
| * |
| * @private |
| * @param {*} value The value to process. |
| * @returns {Array} Returns the property path array. |
| */ |
| function toPath(value) { |
| if (isArray(value)) { |
| return value; |
| } |
| var result = []; |
| baseToString(value).replace(rePropName, function (match, number, quote, string) { |
| result.push(quote ? string.replace(reEscapeChar, '$1') : number || match); |
| }); |
| return result; |
| } |
| /** |
| * Creates a clone of `wrapper`. |
| * |
| * @private |
| * @param {Object} wrapper The wrapper to clone. |
| * @returns {Object} Returns the cloned wrapper. |
| */ |
| function wrapperClone(wrapper) { |
| return wrapper instanceof LazyWrapper ? wrapper.clone() : new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__, arrayCopy(wrapper.__actions__)); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates an array of elements split into groups the length of `size`. |
| * If `collection` can't be split evenly, the final chunk will be the remaining |
| * elements. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to process. |
| * @param {number} [size=1] The length of each chunk. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the new array containing chunks. |
| * @example |
| * |
| * _.chunk(['a', 'b', 'c', 'd'], 2); |
| * // => [['a', 'b'], ['c', 'd']] |
| * |
| * _.chunk(['a', 'b', 'c', 'd'], 3); |
| * // => [['a', 'b', 'c'], ['d']] |
| */ |
| function chunk(array, size, guard) { |
| if (guard ? isIterateeCall(array, size, guard) : size == null) { |
| size = 1; |
| } else { |
| size = nativeMax(nativeFloor(size) || 1, 1); |
| } |
| var index = 0, length = array ? array.length : 0, resIndex = -1, result = Array(nativeCeil(length / size)); |
| while (index < length) { |
| result[++resIndex] = baseSlice(array, index, index += size); |
| } |
| return result; |
| } |
| /** |
| * Creates an array with all falsey values removed. The values `false`, `null`, |
| * `0`, `""`, `undefined`, and `NaN` are falsey. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to compact. |
| * @returns {Array} Returns the new array of filtered values. |
| * @example |
| * |
| * _.compact([0, 1, false, 2, '', 3]); |
| * // => [1, 2, 3] |
| */ |
| function compact(array) { |
| var index = -1, length = array ? array.length : 0, resIndex = -1, result = []; |
| while (++index < length) { |
| var value = array[index]; |
| if (value) { |
| result[++resIndex] = value; |
| } |
| } |
| return result; |
| } |
| /** |
| * Creates an array of unique `array` values not included in the other |
| * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to inspect. |
| * @param {...Array} [values] The arrays of values to exclude. |
| * @returns {Array} Returns the new array of filtered values. |
| * @example |
| * |
| * _.difference([1, 2, 3], [4, 2]); |
| * // => [1, 3] |
| */ |
| var difference = restParam(function (array, values) { |
| return isObjectLike(array) && isArrayLike(array) ? baseDifference(array, baseFlatten(values, false, true)) : []; |
| }); |
| /** |
| * Creates a slice of `array` with `n` elements dropped from the beginning. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {number} [n=1] The number of elements to drop. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.drop([1, 2, 3]); |
| * // => [2, 3] |
| * |
| * _.drop([1, 2, 3], 2); |
| * // => [3] |
| * |
| * _.drop([1, 2, 3], 5); |
| * // => [] |
| * |
| * _.drop([1, 2, 3], 0); |
| * // => [1, 2, 3] |
| */ |
| function drop(array, n, guard) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (guard ? isIterateeCall(array, n, guard) : n == null) { |
| n = 1; |
| } |
| return baseSlice(array, n < 0 ? 0 : n); |
| } |
| /** |
| * Creates a slice of `array` with `n` elements dropped from the end. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {number} [n=1] The number of elements to drop. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.dropRight([1, 2, 3]); |
| * // => [1, 2] |
| * |
| * _.dropRight([1, 2, 3], 2); |
| * // => [1] |
| * |
| * _.dropRight([1, 2, 3], 5); |
| * // => [] |
| * |
| * _.dropRight([1, 2, 3], 0); |
| * // => [1, 2, 3] |
| */ |
| function dropRight(array, n, guard) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (guard ? isIterateeCall(array, n, guard) : n == null) { |
| n = 1; |
| } |
| n = length - (+n || 0); |
| return baseSlice(array, 0, n < 0 ? 0 : n); |
| } |
| /** |
| * Creates a slice of `array` excluding elements dropped from the end. |
| * Elements are dropped until `predicate` returns falsey. The predicate is |
| * bound to `thisArg` and invoked with three arguments: (value, index, array). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that match the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.dropRightWhile([1, 2, 3], function(n) { |
| * return n > 1; |
| * }); |
| * // => [1] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': true }, |
| * { 'user': 'fred', 'active': false }, |
| * { 'user': 'pebbles', 'active': false } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.pluck(_.dropRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user'); |
| * // => ['barney', 'fred'] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.pluck(_.dropRightWhile(users, 'active', false), 'user'); |
| * // => ['barney'] |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.dropRightWhile(users, 'active'), 'user'); |
| * // => ['barney', 'fred', 'pebbles'] |
| */ |
| function dropRightWhile(array, predicate, thisArg) { |
| return array && array.length ? baseWhile(array, getCallback(predicate, thisArg, 3), true, true) : []; |
| } |
| /** |
| * Creates a slice of `array` excluding elements dropped from the beginning. |
| * Elements are dropped until `predicate` returns falsey. The predicate is |
| * bound to `thisArg` and invoked with three arguments: (value, index, array). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.dropWhile([1, 2, 3], function(n) { |
| * return n < 3; |
| * }); |
| * // => [3] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': false }, |
| * { 'user': 'fred', 'active': false }, |
| * { 'user': 'pebbles', 'active': true } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.pluck(_.dropWhile(users, { 'user': 'barney', 'active': false }), 'user'); |
| * // => ['fred', 'pebbles'] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.pluck(_.dropWhile(users, 'active', false), 'user'); |
| * // => ['pebbles'] |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.dropWhile(users, 'active'), 'user'); |
| * // => ['barney', 'fred', 'pebbles'] |
| */ |
| function dropWhile(array, predicate, thisArg) { |
| return array && array.length ? baseWhile(array, getCallback(predicate, thisArg, 3), true) : []; |
| } |
| /** |
| * Fills elements of `array` with `value` from `start` up to, but not |
| * including, `end`. |
| * |
| * **Note:** This method mutates `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to fill. |
| * @param {*} value The value to fill `array` with. |
| * @param {number} [start=0] The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns `array`. |
| * @example |
| * |
| * var array = [1, 2, 3]; |
| * |
| * _.fill(array, 'a'); |
| * console.log(array); |
| * // => ['a', 'a', 'a'] |
| * |
| * _.fill(Array(3), 2); |
| * // => [2, 2, 2] |
| * |
| * _.fill([4, 6, 8], '*', 1, 2); |
| * // => [4, '*', 8] |
| */ |
| function fill(array, value, start, end) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (start && typeof start != 'number' && isIterateeCall(array, value, start)) { |
| start = 0; |
| end = length; |
| } |
| return baseFill(array, value, start, end); |
| } |
| /** |
| * This method is like `_.find` except that it returns the index of the first |
| * element `predicate` returns truthy for instead of the element itself. |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to search. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {number} Returns the index of the found element, else `-1`. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': false }, |
| * { 'user': 'fred', 'active': false }, |
| * { 'user': 'pebbles', 'active': true } |
| * ]; |
| * |
| * _.findIndex(users, function(chr) { |
| * return chr.user == 'barney'; |
| * }); |
| * // => 0 |
| * |
| * // using the `_.matches` callback shorthand |
| * _.findIndex(users, { 'user': 'fred', 'active': false }); |
| * // => 1 |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.findIndex(users, 'active', false); |
| * // => 0 |
| * |
| * // using the `_.property` callback shorthand |
| * _.findIndex(users, 'active'); |
| * // => 2 |
| */ |
| var findIndex = createFindIndex(); |
| /** |
| * This method is like `_.findIndex` except that it iterates over elements |
| * of `collection` from right to left. |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to search. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {number} Returns the index of the found element, else `-1`. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': true }, |
| * { 'user': 'fred', 'active': false }, |
| * { 'user': 'pebbles', 'active': false } |
| * ]; |
| * |
| * _.findLastIndex(users, function(chr) { |
| * return chr.user == 'pebbles'; |
| * }); |
| * // => 2 |
| * |
| * // using the `_.matches` callback shorthand |
| * _.findLastIndex(users, { 'user': 'barney', 'active': true }); |
| * // => 0 |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.findLastIndex(users, 'active', false); |
| * // => 2 |
| * |
| * // using the `_.property` callback shorthand |
| * _.findLastIndex(users, 'active'); |
| * // => 0 |
| */ |
| var findLastIndex = createFindIndex(true); |
| /** |
| * Gets the first element of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias head |
| * @category Array |
| * @param {Array} array The array to query. |
| * @returns {*} Returns the first element of `array`. |
| * @example |
| * |
| * _.first([1, 2, 3]); |
| * // => 1 |
| * |
| * _.first([]); |
| * // => undefined |
| */ |
| function first(array) { |
| return array ? array[0] : undefined; |
| } |
| /** |
| * Flattens a nested array. If `isDeep` is `true` the array is recursively |
| * flattened, otherwise it's only flattened a single level. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to flatten. |
| * @param {boolean} [isDeep] Specify a deep flatten. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the new flattened array. |
| * @example |
| * |
| * _.flatten([1, [2, 3, [4]]]); |
| * // => [1, 2, 3, [4]] |
| * |
| * // using `isDeep` |
| * _.flatten([1, [2, 3, [4]]], true); |
| * // => [1, 2, 3, 4] |
| */ |
| function flatten(array, isDeep, guard) { |
| var length = array ? array.length : 0; |
| if (guard && isIterateeCall(array, isDeep, guard)) { |
| isDeep = false; |
| } |
| return length ? baseFlatten(array, isDeep) : []; |
| } |
| /** |
| * Recursively flattens a nested array. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to recursively flatten. |
| * @returns {Array} Returns the new flattened array. |
| * @example |
| * |
| * _.flattenDeep([1, [2, 3, [4]]]); |
| * // => [1, 2, 3, 4] |
| */ |
| function flattenDeep(array) { |
| var length = array ? array.length : 0; |
| return length ? baseFlatten(array, true) : []; |
| } |
| /** |
| * Gets the index at which the first occurrence of `value` is found in `array` |
| * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. If `fromIndex` is negative, it's used as the offset |
| * from the end of `array`. If `array` is sorted providing `true` for `fromIndex` |
| * performs a faster binary search. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {boolean|number} [fromIndex=0] The index to search from or `true` |
| * to perform a binary search on a sorted array. |
| * @returns {number} Returns the index of the matched value, else `-1`. |
| * @example |
| * |
| * _.indexOf([1, 2, 1, 2], 2); |
| * // => 1 |
| * |
| * // using `fromIndex` |
| * _.indexOf([1, 2, 1, 2], 2, 2); |
| * // => 3 |
| * |
| * // performing a binary search |
| * _.indexOf([1, 1, 2, 2], 2, true); |
| * // => 2 |
| */ |
| function indexOf(array, value, fromIndex) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return -1; |
| } |
| if (typeof fromIndex == 'number') { |
| fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex; |
| } else if (fromIndex) { |
| var index = binaryIndex(array, value); |
| if (index < length && (value === value ? value === array[index] : array[index] !== array[index])) { |
| return index; |
| } |
| return -1; |
| } |
| return baseIndexOf(array, value, fromIndex || 0); |
| } |
| /** |
| * Gets all but the last element of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.initial([1, 2, 3]); |
| * // => [1, 2] |
| */ |
| function initial(array) { |
| return dropRight(array, 1); |
| } |
| /** |
| * Creates an array of unique values that are included in all of the provided |
| * arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {...Array} [arrays] The arrays to inspect. |
| * @returns {Array} Returns the new array of shared values. |
| * @example |
| * _.intersection([1, 2], [4, 2], [2, 1]); |
| * // => [2] |
| */ |
| var intersection = restParam(function (arrays) { |
| var othLength = arrays.length, othIndex = othLength, caches = Array(length), indexOf = getIndexOf(), isCommon = indexOf === baseIndexOf, result = []; |
| while (othIndex--) { |
| var value = arrays[othIndex] = isArrayLike(value = arrays[othIndex]) ? value : []; |
| caches[othIndex] = isCommon && value.length >= 120 ? createCache(othIndex && value) : null; |
| } |
| var array = arrays[0], index = -1, length = array ? array.length : 0, seen = caches[0]; |
| outer: |
| while (++index < length) { |
| value = array[index]; |
| if ((seen ? cacheIndexOf(seen, value) : indexOf(result, value, 0)) < 0) { |
| var othIndex = othLength; |
| while (--othIndex) { |
| var cache = caches[othIndex]; |
| if ((cache ? cacheIndexOf(cache, value) : indexOf(arrays[othIndex], value, 0)) < 0) { |
| continue outer; |
| } |
| } |
| if (seen) { |
| seen.push(value); |
| } |
| result.push(value); |
| } |
| } |
| return result; |
| }); |
| /** |
| * Gets the last element of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @returns {*} Returns the last element of `array`. |
| * @example |
| * |
| * _.last([1, 2, 3]); |
| * // => 3 |
| */ |
| function last(array) { |
| var length = array ? array.length : 0; |
| return length ? array[length - 1] : undefined; |
| } |
| /** |
| * This method is like `_.indexOf` except that it iterates over elements of |
| * `array` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to search. |
| * @param {*} value The value to search for. |
| * @param {boolean|number} [fromIndex=array.length-1] The index to search from |
| * or `true` to perform a binary search on a sorted array. |
| * @returns {number} Returns the index of the matched value, else `-1`. |
| * @example |
| * |
| * _.lastIndexOf([1, 2, 1, 2], 2); |
| * // => 3 |
| * |
| * // using `fromIndex` |
| * _.lastIndexOf([1, 2, 1, 2], 2, 2); |
| * // => 1 |
| * |
| * // performing a binary search |
| * _.lastIndexOf([1, 1, 2, 2], 2, true); |
| * // => 3 |
| */ |
| function lastIndexOf(array, value, fromIndex) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return -1; |
| } |
| var index = length; |
| if (typeof fromIndex == 'number') { |
| index = (fromIndex < 0 ? nativeMax(length + fromIndex, 0) : nativeMin(fromIndex || 0, length - 1)) + 1; |
| } else if (fromIndex) { |
| index = binaryIndex(array, value, true) - 1; |
| var other = array[index]; |
| if (value === value ? value === other : other !== other) { |
| return index; |
| } |
| return -1; |
| } |
| if (value !== value) { |
| return indexOfNaN(array, index, true); |
| } |
| while (index--) { |
| if (array[index] === value) { |
| return index; |
| } |
| } |
| return -1; |
| } |
| /** |
| * Removes all provided values from `array` using |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * **Note:** Unlike `_.without`, this method mutates `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to modify. |
| * @param {...*} [values] The values to remove. |
| * @returns {Array} Returns `array`. |
| * @example |
| * |
| * var array = [1, 2, 3, 1, 2, 3]; |
| * |
| * _.pull(array, 2, 3); |
| * console.log(array); |
| * // => [1, 1] |
| */ |
| function pull() { |
| var args = arguments, array = args[0]; |
| if (!(array && array.length)) { |
| return array; |
| } |
| var index = 0, indexOf = getIndexOf(), length = args.length; |
| while (++index < length) { |
| var fromIndex = 0, value = args[index]; |
| while ((fromIndex = indexOf(array, value, fromIndex)) > -1) { |
| splice.call(array, fromIndex, 1); |
| } |
| } |
| return array; |
| } |
| /** |
| * Removes elements from `array` corresponding to the given indexes and returns |
| * an array of the removed elements. Indexes may be specified as an array of |
| * indexes or as individual arguments. |
| * |
| * **Note:** Unlike `_.at`, this method mutates `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to modify. |
| * @param {...(number|number[])} [indexes] The indexes of elements to remove, |
| * specified as individual indexes or arrays of indexes. |
| * @returns {Array} Returns the new array of removed elements. |
| * @example |
| * |
| * var array = [5, 10, 15, 20]; |
| * var evens = _.pullAt(array, 1, 3); |
| * |
| * console.log(array); |
| * // => [5, 15] |
| * |
| * console.log(evens); |
| * // => [10, 20] |
| */ |
| var pullAt = restParam(function (array, indexes) { |
| indexes = baseFlatten(indexes); |
| var result = baseAt(array, indexes); |
| basePullAt(array, indexes.sort(baseCompareAscending)); |
| return result; |
| }); |
| /** |
| * Removes all elements from `array` that `predicate` returns truthy for |
| * and returns an array of the removed elements. The predicate is bound to |
| * `thisArg` and invoked with three arguments: (value, index, array). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * **Note:** Unlike `_.filter`, this method mutates `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to modify. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the new array of removed elements. |
| * @example |
| * |
| * var array = [1, 2, 3, 4]; |
| * var evens = _.remove(array, function(n) { |
| * return n % 2 == 0; |
| * }); |
| * |
| * console.log(array); |
| * // => [1, 3] |
| * |
| * console.log(evens); |
| * // => [2, 4] |
| */ |
| function remove(array, predicate, thisArg) { |
| var result = []; |
| if (!(array && array.length)) { |
| return result; |
| } |
| var index = -1, indexes = [], length = array.length; |
| predicate = getCallback(predicate, thisArg, 3); |
| while (++index < length) { |
| var value = array[index]; |
| if (predicate(value, index, array)) { |
| result.push(value); |
| indexes.push(index); |
| } |
| } |
| basePullAt(array, indexes); |
| return result; |
| } |
| /** |
| * Gets all but the first element of `array`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias tail |
| * @category Array |
| * @param {Array} array The array to query. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.rest([1, 2, 3]); |
| * // => [2, 3] |
| */ |
| function rest(array) { |
| return drop(array, 1); |
| } |
| /** |
| * Creates a slice of `array` from `start` up to, but not including, `end`. |
| * |
| * **Note:** This method is used instead of `Array#slice` to support node |
| * lists in IE < 9 and to ensure dense arrays are returned. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to slice. |
| * @param {number} [start=0] The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns the slice of `array`. |
| */ |
| function slice(array, start, end) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (end && typeof end != 'number' && isIterateeCall(array, start, end)) { |
| start = 0; |
| end = length; |
| } |
| return baseSlice(array, start, end); |
| } |
| /** |
| * Uses a binary search to determine the lowest index at which `value` should |
| * be inserted into `array` in order to maintain its sort order. If an iteratee |
| * function is provided it's invoked for `value` and each element of `array` |
| * to compute their sort ranking. The iteratee is bound to `thisArg` and |
| * invoked with one argument; (value). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The sorted array to inspect. |
| * @param {*} value The value to evaluate. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {number} Returns the index at which `value` should be inserted |
| * into `array`. |
| * @example |
| * |
| * _.sortedIndex([30, 50], 40); |
| * // => 1 |
| * |
| * _.sortedIndex([4, 4, 5, 5], 5); |
| * // => 2 |
| * |
| * var dict = { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } }; |
| * |
| * // using an iteratee function |
| * _.sortedIndex(['thirty', 'fifty'], 'forty', function(word) { |
| * return this.data[word]; |
| * }, dict); |
| * // => 1 |
| * |
| * // using the `_.property` callback shorthand |
| * _.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); |
| * // => 1 |
| */ |
| var sortedIndex = createSortedIndex(); |
| /** |
| * This method is like `_.sortedIndex` except that it returns the highest |
| * index at which `value` should be inserted into `array` in order to |
| * maintain its sort order. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The sorted array to inspect. |
| * @param {*} value The value to evaluate. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {number} Returns the index at which `value` should be inserted |
| * into `array`. |
| * @example |
| * |
| * _.sortedLastIndex([4, 4, 5, 5], 5); |
| * // => 4 |
| */ |
| var sortedLastIndex = createSortedIndex(true); |
| /** |
| * Creates a slice of `array` with `n` elements taken from the beginning. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {number} [n=1] The number of elements to take. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.take([1, 2, 3]); |
| * // => [1] |
| * |
| * _.take([1, 2, 3], 2); |
| * // => [1, 2] |
| * |
| * _.take([1, 2, 3], 5); |
| * // => [1, 2, 3] |
| * |
| * _.take([1, 2, 3], 0); |
| * // => [] |
| */ |
| function take(array, n, guard) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (guard ? isIterateeCall(array, n, guard) : n == null) { |
| n = 1; |
| } |
| return baseSlice(array, 0, n < 0 ? 0 : n); |
| } |
| /** |
| * Creates a slice of `array` with `n` elements taken from the end. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {number} [n=1] The number of elements to take. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.takeRight([1, 2, 3]); |
| * // => [3] |
| * |
| * _.takeRight([1, 2, 3], 2); |
| * // => [2, 3] |
| * |
| * _.takeRight([1, 2, 3], 5); |
| * // => [1, 2, 3] |
| * |
| * _.takeRight([1, 2, 3], 0); |
| * // => [] |
| */ |
| function takeRight(array, n, guard) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (guard ? isIterateeCall(array, n, guard) : n == null) { |
| n = 1; |
| } |
| n = length - (+n || 0); |
| return baseSlice(array, n < 0 ? 0 : n); |
| } |
| /** |
| * Creates a slice of `array` with elements taken from the end. Elements are |
| * taken until `predicate` returns falsey. The predicate is bound to `thisArg` |
| * and invoked with three arguments: (value, index, array). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.takeRightWhile([1, 2, 3], function(n) { |
| * return n > 1; |
| * }); |
| * // => [2, 3] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': true }, |
| * { 'user': 'fred', 'active': false }, |
| * { 'user': 'pebbles', 'active': false } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.pluck(_.takeRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user'); |
| * // => ['pebbles'] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.pluck(_.takeRightWhile(users, 'active', false), 'user'); |
| * // => ['fred', 'pebbles'] |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.takeRightWhile(users, 'active'), 'user'); |
| * // => [] |
| */ |
| function takeRightWhile(array, predicate, thisArg) { |
| return array && array.length ? baseWhile(array, getCallback(predicate, thisArg, 3), false, true) : []; |
| } |
| /** |
| * Creates a slice of `array` with elements taken from the beginning. Elements |
| * are taken until `predicate` returns falsey. The predicate is bound to |
| * `thisArg` and invoked with three arguments: (value, index, array). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to query. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the slice of `array`. |
| * @example |
| * |
| * _.takeWhile([1, 2, 3], function(n) { |
| * return n < 3; |
| * }); |
| * // => [1, 2] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': false }, |
| * { 'user': 'fred', 'active': false}, |
| * { 'user': 'pebbles', 'active': true } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.pluck(_.takeWhile(users, { 'user': 'barney', 'active': false }), 'user'); |
| * // => ['barney'] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.pluck(_.takeWhile(users, 'active', false), 'user'); |
| * // => ['barney', 'fred'] |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.takeWhile(users, 'active'), 'user'); |
| * // => [] |
| */ |
| function takeWhile(array, predicate, thisArg) { |
| return array && array.length ? baseWhile(array, getCallback(predicate, thisArg, 3)) : []; |
| } |
| /** |
| * Creates an array of unique values, in order, from all of the provided arrays |
| * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {...Array} [arrays] The arrays to inspect. |
| * @returns {Array} Returns the new array of combined values. |
| * @example |
| * |
| * _.union([1, 2], [4, 2], [2, 1]); |
| * // => [1, 2, 4] |
| */ |
| var union = restParam(function (arrays) { |
| return baseUniq(baseFlatten(arrays, false, true)); |
| }); |
| /** |
| * Creates a duplicate-free version of an array, using |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons, in which only the first occurence of each element |
| * is kept. Providing `true` for `isSorted` performs a faster search algorithm |
| * for sorted arrays. If an iteratee function is provided it's invoked for |
| * each element in the array to generate the criterion by which uniqueness |
| * is computed. The `iteratee` is bound to `thisArg` and invoked with three |
| * arguments: (value, index, array). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias unique |
| * @category Array |
| * @param {Array} array The array to inspect. |
| * @param {boolean} [isSorted] Specify the array is sorted. |
| * @param {Function|Object|string} [iteratee] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array} Returns the new duplicate-value-free array. |
| * @example |
| * |
| * _.uniq([2, 1, 2]); |
| * // => [2, 1] |
| * |
| * // using `isSorted` |
| * _.uniq([1, 1, 2], true); |
| * // => [1, 2] |
| * |
| * // using an iteratee function |
| * _.uniq([1, 2.5, 1.5, 2], function(n) { |
| * return this.floor(n); |
| * }, Math); |
| * // => [1, 2.5] |
| * |
| * // using the `_.property` callback shorthand |
| * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); |
| * // => [{ 'x': 1 }, { 'x': 2 }] |
| */ |
| function uniq(array, isSorted, iteratee, thisArg) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| if (isSorted != null && typeof isSorted != 'boolean') { |
| thisArg = iteratee; |
| iteratee = isIterateeCall(array, isSorted, thisArg) ? undefined : isSorted; |
| isSorted = false; |
| } |
| var callback = getCallback(); |
| if (!(iteratee == null && callback === baseCallback)) { |
| iteratee = callback(iteratee, thisArg, 3); |
| } |
| return isSorted && getIndexOf() === baseIndexOf ? sortedUniq(array, iteratee) : baseUniq(array, iteratee); |
| } |
| /** |
| * This method is like `_.zip` except that it accepts an array of grouped |
| * elements and creates an array regrouping the elements to their pre-zip |
| * configuration. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array of grouped elements to process. |
| * @returns {Array} Returns the new array of regrouped elements. |
| * @example |
| * |
| * var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]); |
| * // => [['fred', 30, true], ['barney', 40, false]] |
| * |
| * _.unzip(zipped); |
| * // => [['fred', 'barney'], [30, 40], [true, false]] |
| */ |
| function unzip(array) { |
| if (!(array && array.length)) { |
| return []; |
| } |
| var index = -1, length = 0; |
| array = arrayFilter(array, function (group) { |
| if (isArrayLike(group)) { |
| length = nativeMax(group.length, length); |
| return true; |
| } |
| }); |
| var result = Array(length); |
| while (++index < length) { |
| result[index] = arrayMap(array, baseProperty(index)); |
| } |
| return result; |
| } |
| /** |
| * This method is like `_.unzip` except that it accepts an iteratee to specify |
| * how regrouped values should be combined. The `iteratee` is bound to `thisArg` |
| * and invoked with four arguments: (accumulator, value, index, group). |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array of grouped elements to process. |
| * @param {Function} [iteratee] The function to combine regrouped values. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array} Returns the new array of regrouped elements. |
| * @example |
| * |
| * var zipped = _.zip([1, 2], [10, 20], [100, 200]); |
| * // => [[1, 10, 100], [2, 20, 200]] |
| * |
| * _.unzipWith(zipped, _.add); |
| * // => [3, 30, 300] |
| */ |
| function unzipWith(array, iteratee, thisArg) { |
| var length = array ? array.length : 0; |
| if (!length) { |
| return []; |
| } |
| var result = unzip(array); |
| if (iteratee == null) { |
| return result; |
| } |
| iteratee = bindCallback(iteratee, thisArg, 4); |
| return arrayMap(result, function (group) { |
| return arrayReduce(group, iteratee, undefined, true); |
| }); |
| } |
| /** |
| * Creates an array excluding all provided values using |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {Array} array The array to filter. |
| * @param {...*} [values] The values to exclude. |
| * @returns {Array} Returns the new array of filtered values. |
| * @example |
| * |
| * _.without([1, 2, 1, 3], 1, 2); |
| * // => [3] |
| */ |
| var without = restParam(function (array, values) { |
| return isArrayLike(array) ? baseDifference(array, values) : []; |
| }); |
| /** |
| * Creates an array of unique values that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) |
| * of the provided arrays. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {...Array} [arrays] The arrays to inspect. |
| * @returns {Array} Returns the new array of values. |
| * @example |
| * |
| * _.xor([1, 2], [4, 2]); |
| * // => [1, 4] |
| */ |
| function xor() { |
| var index = -1, length = arguments.length; |
| while (++index < length) { |
| var array = arguments[index]; |
| if (isArrayLike(array)) { |
| var result = result ? arrayPush(baseDifference(result, array), baseDifference(array, result)) : array; |
| } |
| } |
| return result ? baseUniq(result) : []; |
| } |
| /** |
| * Creates an array of grouped elements, the first of which contains the first |
| * elements of the given arrays, the second of which contains the second elements |
| * of the given arrays, and so on. |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {...Array} [arrays] The arrays to process. |
| * @returns {Array} Returns the new array of grouped elements. |
| * @example |
| * |
| * _.zip(['fred', 'barney'], [30, 40], [true, false]); |
| * // => [['fred', 30, true], ['barney', 40, false]] |
| */ |
| var zip = restParam(unzip); |
| /** |
| * The inverse of `_.pairs`; this method returns an object composed from arrays |
| * of property names and values. Provide either a single two dimensional array, |
| * e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names |
| * and one of corresponding values. |
| * |
| * @static |
| * @memberOf _ |
| * @alias object |
| * @category Array |
| * @param {Array} props The property names. |
| * @param {Array} [values=[]] The property values. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * _.zipObject([['fred', 30], ['barney', 40]]); |
| * // => { 'fred': 30, 'barney': 40 } |
| * |
| * _.zipObject(['fred', 'barney'], [30, 40]); |
| * // => { 'fred': 30, 'barney': 40 } |
| */ |
| function zipObject(props, values) { |
| var index = -1, length = props ? props.length : 0, result = {}; |
| if (length && !values && !isArray(props[0])) { |
| values = []; |
| } |
| while (++index < length) { |
| var key = props[index]; |
| if (values) { |
| result[key] = values[index]; |
| } else if (key) { |
| result[key[0]] = key[1]; |
| } |
| } |
| return result; |
| } |
| /** |
| * This method is like `_.zip` except that it accepts an iteratee to specify |
| * how grouped values should be combined. The `iteratee` is bound to `thisArg` |
| * and invoked with four arguments: (accumulator, value, index, group). |
| * |
| * @static |
| * @memberOf _ |
| * @category Array |
| * @param {...Array} [arrays] The arrays to process. |
| * @param {Function} [iteratee] The function to combine grouped values. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array} Returns the new array of grouped elements. |
| * @example |
| * |
| * _.zipWith([1, 2], [10, 20], [100, 200], _.add); |
| * // => [111, 222] |
| */ |
| var zipWith = restParam(function (arrays) { |
| var length = arrays.length, iteratee = length > 2 ? arrays[length - 2] : undefined, thisArg = length > 1 ? arrays[length - 1] : undefined; |
| if (length > 2 && typeof iteratee == 'function') { |
| length -= 2; |
| } else { |
| iteratee = length > 1 && typeof thisArg == 'function' ? (--length, thisArg) : undefined; |
| thisArg = undefined; |
| } |
| arrays.length = length; |
| return unzipWith(arrays, iteratee, thisArg); |
| }); |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates a `lodash` object that wraps `value` with explicit method |
| * chaining enabled. |
| * |
| * @static |
| * @memberOf _ |
| * @category Chain |
| * @param {*} value The value to wrap. |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 }, |
| * { 'user': 'pebbles', 'age': 1 } |
| * ]; |
| * |
| * var youngest = _.chain(users) |
| * .sortBy('age') |
| * .map(function(chr) { |
| * return chr.user + ' is ' + chr.age; |
| * }) |
| * .first() |
| * .value(); |
| * // => 'pebbles is 1' |
| */ |
| function chain(value) { |
| var result = lodash(value); |
| result.__chain__ = true; |
| return result; |
| } |
| /** |
| * This method invokes `interceptor` and returns `value`. The interceptor is |
| * bound to `thisArg` and invoked with one argument; (value). The purpose of |
| * this method is to "tap into" a method chain in order to perform operations |
| * on intermediate results within the chain. |
| * |
| * @static |
| * @memberOf _ |
| * @category Chain |
| * @param {*} value The value to provide to `interceptor`. |
| * @param {Function} interceptor The function to invoke. |
| * @param {*} [thisArg] The `this` binding of `interceptor`. |
| * @returns {*} Returns `value`. |
| * @example |
| * |
| * _([1, 2, 3]) |
| * .tap(function(array) { |
| * array.pop(); |
| * }) |
| * .reverse() |
| * .value(); |
| * // => [2, 1] |
| */ |
| function tap(value, interceptor, thisArg) { |
| interceptor.call(thisArg, value); |
| return value; |
| } |
| /** |
| * This method is like `_.tap` except that it returns the result of `interceptor`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Chain |
| * @param {*} value The value to provide to `interceptor`. |
| * @param {Function} interceptor The function to invoke. |
| * @param {*} [thisArg] The `this` binding of `interceptor`. |
| * @returns {*} Returns the result of `interceptor`. |
| * @example |
| * |
| * _(' abc ') |
| * .chain() |
| * .trim() |
| * .thru(function(value) { |
| * return [value]; |
| * }) |
| * .value(); |
| * // => ['abc'] |
| */ |
| function thru(value, interceptor, thisArg) { |
| return interceptor.call(thisArg, value); |
| } |
| /** |
| * Enables explicit method chaining on the wrapper object. |
| * |
| * @name chain |
| * @memberOf _ |
| * @category Chain |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // without explicit chaining |
| * _(users).first(); |
| * // => { 'user': 'barney', 'age': 36 } |
| * |
| * // with explicit chaining |
| * _(users).chain() |
| * .first() |
| * .pick('user') |
| * .value(); |
| * // => { 'user': 'barney' } |
| */ |
| function wrapperChain() { |
| return chain(this); |
| } |
| /** |
| * Executes the chained sequence and returns the wrapped result. |
| * |
| * @name commit |
| * @memberOf _ |
| * @category Chain |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var array = [1, 2]; |
| * var wrapped = _(array).push(3); |
| * |
| * console.log(array); |
| * // => [1, 2] |
| * |
| * wrapped = wrapped.commit(); |
| * console.log(array); |
| * // => [1, 2, 3] |
| * |
| * wrapped.last(); |
| * // => 3 |
| * |
| * console.log(array); |
| * // => [1, 2, 3] |
| */ |
| function wrapperCommit() { |
| return new LodashWrapper(this.value(), this.__chain__); |
| } |
| /** |
| * Creates a new array joining a wrapped array with any additional arrays |
| * and/or values. |
| * |
| * @name concat |
| * @memberOf _ |
| * @category Chain |
| * @param {...*} [values] The values to concatenate. |
| * @returns {Array} Returns the new concatenated array. |
| * @example |
| * |
| * var array = [1]; |
| * var wrapped = _(array).concat(2, [3], [[4]]); |
| * |
| * console.log(wrapped.value()); |
| * // => [1, 2, 3, [4]] |
| * |
| * console.log(array); |
| * // => [1] |
| */ |
| var wrapperConcat = restParam(function (values) { |
| values = baseFlatten(values); |
| return this.thru(function (array) { |
| return arrayConcat(isArray(array) ? array : [toObject(array)], values); |
| }); |
| }); |
| /** |
| * Creates a clone of the chained sequence planting `value` as the wrapped value. |
| * |
| * @name plant |
| * @memberOf _ |
| * @category Chain |
| * @returns {Object} Returns the new `lodash` wrapper instance. |
| * @example |
| * |
| * var array = [1, 2]; |
| * var wrapped = _(array).map(function(value) { |
| * return Math.pow(value, 2); |
| * }); |
| * |
| * var other = [3, 4]; |
| * var otherWrapped = wrapped.plant(other); |
| * |
| * otherWrapped.value(); |
| * // => [9, 16] |
| * |
| * wrapped.value(); |
| * // => [1, 4] |
| */ |
| function wrapperPlant(value) { |
| var result, parent = this; |
| while (parent instanceof baseLodash) { |
| var clone = wrapperClone(parent); |
| if (result) { |
| previous.__wrapped__ = clone; |
| } else { |
| result = clone; |
| } |
| var previous = clone; |
| parent = parent.__wrapped__; |
| } |
| previous.__wrapped__ = value; |
| return result; |
| } |
| /** |
| * Reverses the wrapped array so the first element becomes the last, the |
| * second element becomes the second to last, and so on. |
| * |
| * **Note:** This method mutates the wrapped array. |
| * |
| * @name reverse |
| * @memberOf _ |
| * @category Chain |
| * @returns {Object} Returns the new reversed `lodash` wrapper instance. |
| * @example |
| * |
| * var array = [1, 2, 3]; |
| * |
| * _(array).reverse().value() |
| * // => [3, 2, 1] |
| * |
| * console.log(array); |
| * // => [3, 2, 1] |
| */ |
| function wrapperReverse() { |
| var value = this.__wrapped__; |
| var interceptor = function (value) { |
| return value.reverse(); |
| }; |
| if (value instanceof LazyWrapper) { |
| var wrapped = value; |
| if (this.__actions__.length) { |
| wrapped = new LazyWrapper(this); |
| } |
| wrapped = wrapped.reverse(); |
| wrapped.__actions__.push({ |
| 'func': thru, |
| 'args': [interceptor], |
| 'thisArg': undefined |
| }); |
| return new LodashWrapper(wrapped, this.__chain__); |
| } |
| return this.thru(interceptor); |
| } |
| /** |
| * Produces the result of coercing the unwrapped value to a string. |
| * |
| * @name toString |
| * @memberOf _ |
| * @category Chain |
| * @returns {string} Returns the coerced string value. |
| * @example |
| * |
| * _([1, 2, 3]).toString(); |
| * // => '1,2,3' |
| */ |
| function wrapperToString() { |
| return this.value() + ''; |
| } |
| /** |
| * Executes the chained sequence to extract the unwrapped value. |
| * |
| * @name value |
| * @memberOf _ |
| * @alias run, toJSON, valueOf |
| * @category Chain |
| * @returns {*} Returns the resolved unwrapped value. |
| * @example |
| * |
| * _([1, 2, 3]).value(); |
| * // => [1, 2, 3] |
| */ |
| function wrapperValue() { |
| return baseWrapperValue(this.__wrapped__, this.__actions__); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates an array of elements corresponding to the given keys, or indexes, |
| * of `collection`. Keys may be specified as individual arguments or as arrays |
| * of keys. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {...(number|number[]|string|string[])} [props] The property names |
| * or indexes of elements to pick, specified individually or in arrays. |
| * @returns {Array} Returns the new array of picked elements. |
| * @example |
| * |
| * _.at(['a', 'b', 'c'], [0, 2]); |
| * // => ['a', 'c'] |
| * |
| * _.at(['barney', 'fred', 'pebbles'], 0, 2); |
| * // => ['barney', 'pebbles'] |
| */ |
| var at = restParam(function (collection, props) { |
| return baseAt(collection, baseFlatten(props)); |
| }); |
| /** |
| * Creates an object composed of keys generated from the results of running |
| * each element of `collection` through `iteratee`. The corresponding value |
| * of each key is the number of times the key was returned by `iteratee`. |
| * The `iteratee` is bound to `thisArg` and invoked with three arguments: |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns the composed aggregate object. |
| * @example |
| * |
| * _.countBy([4.3, 6.1, 6.4], function(n) { |
| * return Math.floor(n); |
| * }); |
| * // => { '4': 1, '6': 2 } |
| * |
| * _.countBy([4.3, 6.1, 6.4], function(n) { |
| * return this.floor(n); |
| * }, Math); |
| * // => { '4': 1, '6': 2 } |
| * |
| * _.countBy(['one', 'two', 'three'], 'length'); |
| * // => { '3': 2, '5': 1 } |
| */ |
| var countBy = createAggregator(function (result, value, key) { |
| hasOwnProperty.call(result, key) ? ++result[key] : result[key] = 1; |
| }); |
| /** |
| * Checks if `predicate` returns truthy for **all** elements of `collection`. |
| * The predicate is bound to `thisArg` and invoked with three arguments: |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias all |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {boolean} Returns `true` if all elements pass the predicate check, |
| * else `false`. |
| * @example |
| * |
| * _.every([true, 1, null, 'yes'], Boolean); |
| * // => false |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': false }, |
| * { 'user': 'fred', 'active': false } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.every(users, { 'user': 'barney', 'active': false }); |
| * // => false |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.every(users, 'active', false); |
| * // => true |
| * |
| * // using the `_.property` callback shorthand |
| * _.every(users, 'active'); |
| * // => false |
| */ |
| function every(collection, predicate, thisArg) { |
| var func = isArray(collection) ? arrayEvery : baseEvery; |
| if (thisArg && isIterateeCall(collection, predicate, thisArg)) { |
| predicate = undefined; |
| } |
| if (typeof predicate != 'function' || thisArg !== undefined) { |
| predicate = getCallback(predicate, thisArg, 3); |
| } |
| return func(collection, predicate); |
| } |
| /** |
| * Iterates over elements of `collection`, returning an array of all elements |
| * `predicate` returns truthy for. The predicate is bound to `thisArg` and |
| * invoked with three arguments: (value, index|key, collection). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias select |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the new filtered array. |
| * @example |
| * |
| * _.filter([4, 5, 6], function(n) { |
| * return n % 2 == 0; |
| * }); |
| * // => [4, 6] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user'); |
| * // => ['barney'] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.pluck(_.filter(users, 'active', false), 'user'); |
| * // => ['fred'] |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.filter(users, 'active'), 'user'); |
| * // => ['barney'] |
| */ |
| function filter(collection, predicate, thisArg) { |
| var func = isArray(collection) ? arrayFilter : baseFilter; |
| predicate = getCallback(predicate, thisArg, 3); |
| return func(collection, predicate); |
| } |
| /** |
| * Iterates over elements of `collection`, returning the first element |
| * `predicate` returns truthy for. The predicate is bound to `thisArg` and |
| * invoked with three arguments: (value, index|key, collection). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias detect |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to search. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {*} Returns the matched element, else `undefined`. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false }, |
| * { 'user': 'pebbles', 'age': 1, 'active': true } |
| * ]; |
| * |
| * _.result(_.find(users, function(chr) { |
| * return chr.age < 40; |
| * }), 'user'); |
| * // => 'barney' |
| * |
| * // using the `_.matches` callback shorthand |
| * _.result(_.find(users, { 'age': 1, 'active': true }), 'user'); |
| * // => 'pebbles' |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.result(_.find(users, 'active', false), 'user'); |
| * // => 'fred' |
| * |
| * // using the `_.property` callback shorthand |
| * _.result(_.find(users, 'active'), 'user'); |
| * // => 'barney' |
| */ |
| var find = createFind(baseEach); |
| /** |
| * This method is like `_.find` except that it iterates over elements of |
| * `collection` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to search. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {*} Returns the matched element, else `undefined`. |
| * @example |
| * |
| * _.findLast([1, 2, 3, 4], function(n) { |
| * return n % 2 == 1; |
| * }); |
| * // => 3 |
| */ |
| var findLast = createFind(baseEachRight, true); |
| /** |
| * Performs a deep comparison between each element in `collection` and the |
| * source object, returning the first element that has equivalent property |
| * values. |
| * |
| * **Note:** This method supports comparing arrays, booleans, `Date` objects, |
| * numbers, `Object` objects, regexes, and strings. Objects are compared by |
| * their own, not inherited, enumerable properties. For comparing a single |
| * own or inherited property value see `_.matchesProperty`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to search. |
| * @param {Object} source The object of property values to match. |
| * @returns {*} Returns the matched element, else `undefined`. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * _.result(_.findWhere(users, { 'age': 36, 'active': true }), 'user'); |
| * // => 'barney' |
| * |
| * _.result(_.findWhere(users, { 'age': 40, 'active': false }), 'user'); |
| * // => 'fred' |
| */ |
| function findWhere(collection, source) { |
| return find(collection, baseMatches(source)); |
| } |
| /** |
| * Iterates over elements of `collection` invoking `iteratee` for each element. |
| * The `iteratee` is bound to `thisArg` and invoked with three arguments: |
| * (value, index|key, collection). Iteratee functions may exit iteration early |
| * by explicitly returning `false`. |
| * |
| * **Note:** As with other "Collections" methods, objects with a "length" property |
| * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn` |
| * may be used for object iteration. |
| * |
| * @static |
| * @memberOf _ |
| * @alias each |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array|Object|string} Returns `collection`. |
| * @example |
| * |
| * _([1, 2]).forEach(function(n) { |
| * console.log(n); |
| * }).value(); |
| * // => logs each value from left to right and returns the array |
| * |
| * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) { |
| * console.log(n, key); |
| * }); |
| * // => logs each value-key pair and returns the object (iteration order is not guaranteed) |
| */ |
| var forEach = createForEach(arrayEach, baseEach); |
| /** |
| * This method is like `_.forEach` except that it iterates over elements of |
| * `collection` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @alias eachRight |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array|Object|string} Returns `collection`. |
| * @example |
| * |
| * _([1, 2]).forEachRight(function(n) { |
| * console.log(n); |
| * }).value(); |
| * // => logs each value from right to left and returns the array |
| */ |
| var forEachRight = createForEach(arrayEachRight, baseEachRight); |
| /** |
| * Creates an object composed of keys generated from the results of running |
| * each element of `collection` through `iteratee`. The corresponding value |
| * of each key is an array of the elements responsible for generating the key. |
| * The `iteratee` is bound to `thisArg` and invoked with three arguments: |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns the composed aggregate object. |
| * @example |
| * |
| * _.groupBy([4.2, 6.1, 6.4], function(n) { |
| * return Math.floor(n); |
| * }); |
| * // => { '4': [4.2], '6': [6.1, 6.4] } |
| * |
| * _.groupBy([4.2, 6.1, 6.4], function(n) { |
| * return this.floor(n); |
| * }, Math); |
| * // => { '4': [4.2], '6': [6.1, 6.4] } |
| * |
| * // using the `_.property` callback shorthand |
| * _.groupBy(['one', 'two', 'three'], 'length'); |
| * // => { '3': ['one', 'two'], '5': ['three'] } |
| */ |
| var groupBy = createAggregator(function (result, value, key) { |
| if (hasOwnProperty.call(result, key)) { |
| result[key].push(value); |
| } else { |
| result[key] = [value]; |
| } |
| }); |
| /** |
| * Checks if `target` is in `collection` using |
| * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) |
| * for equality comparisons. If `fromIndex` is negative, it's used as the offset |
| * from the end of `collection`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias contains, include |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to search. |
| * @param {*} target The value to search for. |
| * @param {number} [fromIndex=0] The index to search from. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`. |
| * @returns {boolean} Returns `true` if a matching element is found, else `false`. |
| * @example |
| * |
| * _.includes([1, 2, 3], 1); |
| * // => true |
| * |
| * _.includes([1, 2, 3], 1, 2); |
| * // => false |
| * |
| * _.includes({ 'user': 'fred', 'age': 40 }, 'fred'); |
| * // => true |
| * |
| * _.includes('pebbles', 'eb'); |
| * // => true |
| */ |
| function includes(collection, target, fromIndex, guard) { |
| var length = collection ? getLength(collection) : 0; |
| if (!isLength(length)) { |
| collection = values(collection); |
| length = collection.length; |
| } |
| if (typeof fromIndex != 'number' || guard && isIterateeCall(target, fromIndex, guard)) { |
| fromIndex = 0; |
| } else { |
| fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex || 0; |
| } |
| return typeof collection == 'string' || !isArray(collection) && isString(collection) ? fromIndex <= length && collection.indexOf(target, fromIndex) > -1 : !!length && getIndexOf(collection, target, fromIndex) > -1; |
| } |
| /** |
| * Creates an object composed of keys generated from the results of running |
| * each element of `collection` through `iteratee`. The corresponding value |
| * of each key is the last element responsible for generating the key. The |
| * iteratee function is bound to `thisArg` and invoked with three arguments: |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns the composed aggregate object. |
| * @example |
| * |
| * var keyData = [ |
| * { 'dir': 'left', 'code': 97 }, |
| * { 'dir': 'right', 'code': 100 } |
| * ]; |
| * |
| * _.indexBy(keyData, 'dir'); |
| * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } |
| * |
| * _.indexBy(keyData, function(object) { |
| * return String.fromCharCode(object.code); |
| * }); |
| * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } |
| * |
| * _.indexBy(keyData, function(object) { |
| * return this.fromCharCode(object.code); |
| * }, String); |
| * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } |
| */ |
| var indexBy = createAggregator(function (result, value, key) { |
| result[key] = value; |
| }); |
| /** |
| * Invokes the method at `path` of each element in `collection`, returning |
| * an array of the results of each invoked method. Any additional arguments |
| * are provided to each invoked method. If `methodName` is a function it's |
| * invoked for, and `this` bound to, each element in `collection`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Array|Function|string} path The path of the method to invoke or |
| * the function invoked per iteration. |
| * @param {...*} [args] The arguments to invoke the method with. |
| * @returns {Array} Returns the array of results. |
| * @example |
| * |
| * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); |
| * // => [[1, 5, 7], [1, 2, 3]] |
| * |
| * _.invoke([123, 456], String.prototype.split, ''); |
| * // => [['1', '2', '3'], ['4', '5', '6']] |
| */ |
| var invoke = restParam(function (collection, path, args) { |
| var index = -1, isFunc = typeof path == 'function', isProp = isKey(path), result = isArrayLike(collection) ? Array(collection.length) : []; |
| baseEach(collection, function (value) { |
| var func = isFunc ? path : isProp && value != null ? value[path] : undefined; |
| result[++index] = func ? func.apply(value, args) : invokePath(value, path, args); |
| }); |
| return result; |
| }); |
| /** |
| * Creates an array of values by running each element in `collection` through |
| * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three |
| * arguments: (value, index|key, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * Many lodash methods are guarded to work as iteratees for methods like |
| * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. |
| * |
| * The guarded methods are: |
| * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`, |
| * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`, |
| * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`, |
| * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`, |
| * `sum`, `uniq`, and `words` |
| * |
| * @static |
| * @memberOf _ |
| * @alias collect |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array} Returns the new mapped array. |
| * @example |
| * |
| * function timesThree(n) { |
| * return n * 3; |
| * } |
| * |
| * _.map([1, 2], timesThree); |
| * // => [3, 6] |
| * |
| * _.map({ 'a': 1, 'b': 2 }, timesThree); |
| * // => [3, 6] (iteration order is not guaranteed) |
| * |
| * var users = [ |
| * { 'user': 'barney' }, |
| * { 'user': 'fred' } |
| * ]; |
| * |
| * // using the `_.property` callback shorthand |
| * _.map(users, 'user'); |
| * // => ['barney', 'fred'] |
| */ |
| function map(collection, iteratee, thisArg) { |
| var func = isArray(collection) ? arrayMap : baseMap; |
| iteratee = getCallback(iteratee, thisArg, 3); |
| return func(collection, iteratee); |
| } |
| /** |
| * Creates an array of elements split into two groups, the first of which |
| * contains elements `predicate` returns truthy for, while the second of which |
| * contains elements `predicate` returns falsey for. The predicate is bound |
| * to `thisArg` and invoked with three arguments: (value, index|key, collection). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the array of grouped elements. |
| * @example |
| * |
| * _.partition([1, 2, 3], function(n) { |
| * return n % 2; |
| * }); |
| * // => [[1, 3], [2]] |
| * |
| * _.partition([1.2, 2.3, 3.4], function(n) { |
| * return this.floor(n) % 2; |
| * }, Math); |
| * // => [[1.2, 3.4], [2.3]] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': false }, |
| * { 'user': 'fred', 'age': 40, 'active': true }, |
| * { 'user': 'pebbles', 'age': 1, 'active': false } |
| * ]; |
| * |
| * var mapper = function(array) { |
| * return _.pluck(array, 'user'); |
| * }; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.map(_.partition(users, { 'age': 1, 'active': false }), mapper); |
| * // => [['pebbles'], ['barney', 'fred']] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.map(_.partition(users, 'active', false), mapper); |
| * // => [['barney', 'pebbles'], ['fred']] |
| * |
| * // using the `_.property` callback shorthand |
| * _.map(_.partition(users, 'active'), mapper); |
| * // => [['fred'], ['barney', 'pebbles']] |
| */ |
| var partition = createAggregator(function (result, value, key) { |
| result[key ? 0 : 1].push(value); |
| }, function () { |
| return [ |
| [], |
| [] |
| ]; |
| }); |
| /** |
| * Gets the property value of `path` from all elements in `collection`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Array|string} path The path of the property to pluck. |
| * @returns {Array} Returns the property values. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 } |
| * ]; |
| * |
| * _.pluck(users, 'user'); |
| * // => ['barney', 'fred'] |
| * |
| * var userIndex = _.indexBy(users, 'user'); |
| * _.pluck(userIndex, 'age'); |
| * // => [36, 40] (iteration order is not guaranteed) |
| */ |
| function pluck(collection, path) { |
| return map(collection, property(path)); |
| } |
| /** |
| * Reduces `collection` to a value which is the accumulated result of running |
| * each element in `collection` through `iteratee`, where each successive |
| * invocation is supplied the return value of the previous. If `accumulator` |
| * is not provided the first element of `collection` is used as the initial |
| * value. The `iteratee` is bound to `thisArg` and invoked with four arguments: |
| * (accumulator, value, index|key, collection). |
| * |
| * Many lodash methods are guarded to work as iteratees for methods like |
| * `_.reduce`, `_.reduceRight`, and `_.transform`. |
| * |
| * The guarded methods are: |
| * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `sortByAll`, |
| * and `sortByOrder` |
| * |
| * @static |
| * @memberOf _ |
| * @alias foldl, inject |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [accumulator] The initial value. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {*} Returns the accumulated value. |
| * @example |
| * |
| * _.reduce([1, 2], function(total, n) { |
| * return total + n; |
| * }); |
| * // => 3 |
| * |
| * _.reduce({ 'a': 1, 'b': 2 }, function(result, n, key) { |
| * result[key] = n * 3; |
| * return result; |
| * }, {}); |
| * // => { 'a': 3, 'b': 6 } (iteration order is not guaranteed) |
| */ |
| var reduce = createReduce(arrayReduce, baseEach); |
| /** |
| * This method is like `_.reduce` except that it iterates over elements of |
| * `collection` from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @alias foldr |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [accumulator] The initial value. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {*} Returns the accumulated value. |
| * @example |
| * |
| * var array = [[0, 1], [2, 3], [4, 5]]; |
| * |
| * _.reduceRight(array, function(flattened, other) { |
| * return flattened.concat(other); |
| * }, []); |
| * // => [4, 5, 2, 3, 0, 1] |
| */ |
| var reduceRight = createReduce(arrayReduceRight, baseEachRight); |
| /** |
| * The opposite of `_.filter`; this method returns the elements of `collection` |
| * that `predicate` does **not** return truthy for. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Array} Returns the new filtered array. |
| * @example |
| * |
| * _.reject([1, 2, 3, 4], function(n) { |
| * return n % 2 == 0; |
| * }); |
| * // => [1, 3] |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': false }, |
| * { 'user': 'fred', 'age': 40, 'active': true } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.pluck(_.reject(users, { 'age': 40, 'active': true }), 'user'); |
| * // => ['barney'] |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.pluck(_.reject(users, 'active', false), 'user'); |
| * // => ['fred'] |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.reject(users, 'active'), 'user'); |
| * // => ['barney'] |
| */ |
| function reject(collection, predicate, thisArg) { |
| var func = isArray(collection) ? arrayFilter : baseFilter; |
| predicate = getCallback(predicate, thisArg, 3); |
| return func(collection, function (value, index, collection) { |
| return !predicate(value, index, collection); |
| }); |
| } |
| /** |
| * Gets a random element or `n` random elements from a collection. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to sample. |
| * @param {number} [n] The number of elements to sample. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {*} Returns the random sample(s). |
| * @example |
| * |
| * _.sample([1, 2, 3, 4]); |
| * // => 2 |
| * |
| * _.sample([1, 2, 3, 4], 2); |
| * // => [3, 1] |
| */ |
| function sample(collection, n, guard) { |
| if (guard ? isIterateeCall(collection, n, guard) : n == null) { |
| collection = toIterable(collection); |
| var length = collection.length; |
| return length > 0 ? collection[baseRandom(0, length - 1)] : undefined; |
| } |
| var index = -1, result = toArray(collection), length = result.length, lastIndex = length - 1; |
| n = nativeMin(n < 0 ? 0 : +n || 0, length); |
| while (++index < n) { |
| var rand = baseRandom(index, lastIndex), value = result[rand]; |
| result[rand] = result[index]; |
| result[index] = value; |
| } |
| result.length = n; |
| return result; |
| } |
| /** |
| * Creates an array of shuffled values, using a version of the |
| * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to shuffle. |
| * @returns {Array} Returns the new shuffled array. |
| * @example |
| * |
| * _.shuffle([1, 2, 3, 4]); |
| * // => [4, 1, 3, 2] |
| */ |
| function shuffle(collection) { |
| return sample(collection, POSITIVE_INFINITY); |
| } |
| /** |
| * Gets the size of `collection` by returning its length for array-like |
| * values or the number of own enumerable properties for objects. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to inspect. |
| * @returns {number} Returns the size of `collection`. |
| * @example |
| * |
| * _.size([1, 2, 3]); |
| * // => 3 |
| * |
| * _.size({ 'a': 1, 'b': 2 }); |
| * // => 2 |
| * |
| * _.size('pebbles'); |
| * // => 7 |
| */ |
| function size(collection) { |
| var length = collection ? getLength(collection) : 0; |
| return isLength(length) ? length : keys(collection).length; |
| } |
| /** |
| * Checks if `predicate` returns truthy for **any** element of `collection`. |
| * The function returns as soon as it finds a passing value and does not iterate |
| * over the entire collection. The predicate is bound to `thisArg` and invoked |
| * with three arguments: (value, index|key, collection). |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias any |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {boolean} Returns `true` if any element passes the predicate check, |
| * else `false`. |
| * @example |
| * |
| * _.some([null, 0, 'yes', false], Boolean); |
| * // => true |
| * |
| * var users = [ |
| * { 'user': 'barney', 'active': true }, |
| * { 'user': 'fred', 'active': false } |
| * ]; |
| * |
| * // using the `_.matches` callback shorthand |
| * _.some(users, { 'user': 'barney', 'active': false }); |
| * // => false |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.some(users, 'active', false); |
| * // => true |
| * |
| * // using the `_.property` callback shorthand |
| * _.some(users, 'active'); |
| * // => true |
| */ |
| function some(collection, predicate, thisArg) { |
| var func = isArray(collection) ? arraySome : baseSome; |
| if (thisArg && isIterateeCall(collection, predicate, thisArg)) { |
| predicate = undefined; |
| } |
| if (typeof predicate != 'function' || thisArg !== undefined) { |
| predicate = getCallback(predicate, thisArg, 3); |
| } |
| return func(collection, predicate); |
| } |
| /** |
| * Creates an array of elements, sorted in ascending order by the results of |
| * running each element in a collection through `iteratee`. This method performs |
| * a stable sort, that is, it preserves the original sort order of equal elements. |
| * The `iteratee` is bound to `thisArg` and invoked with three arguments: |
| * (value, index|key, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array} Returns the new sorted array. |
| * @example |
| * |
| * _.sortBy([1, 2, 3], function(n) { |
| * return Math.sin(n); |
| * }); |
| * // => [3, 1, 2] |
| * |
| * _.sortBy([1, 2, 3], function(n) { |
| * return this.sin(n); |
| * }, Math); |
| * // => [3, 1, 2] |
| * |
| * var users = [ |
| * { 'user': 'fred' }, |
| * { 'user': 'pebbles' }, |
| * { 'user': 'barney' } |
| * ]; |
| * |
| * // using the `_.property` callback shorthand |
| * _.pluck(_.sortBy(users, 'user'), 'user'); |
| * // => ['barney', 'fred', 'pebbles'] |
| */ |
| function sortBy(collection, iteratee, thisArg) { |
| if (collection == null) { |
| return []; |
| } |
| if (thisArg && isIterateeCall(collection, iteratee, thisArg)) { |
| iteratee = undefined; |
| } |
| var index = -1; |
| iteratee = getCallback(iteratee, thisArg, 3); |
| var result = baseMap(collection, function (value, key, collection) { |
| return { |
| 'criteria': iteratee(value, key, collection), |
| 'index': ++index, |
| 'value': value |
| }; |
| }); |
| return baseSortBy(result, compareAscending); |
| } |
| /** |
| * This method is like `_.sortBy` except that it can sort by multiple iteratees |
| * or property names. |
| * |
| * If a property name is provided for an iteratee the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If an object is provided for an iteratee the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {...(Function|Function[]|Object|Object[]|string|string[])} iteratees |
| * The iteratees to sort by, specified as individual values or arrays of values. |
| * @returns {Array} Returns the new sorted array. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'fred', 'age': 48 }, |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 42 }, |
| * { 'user': 'barney', 'age': 34 } |
| * ]; |
| * |
| * _.map(_.sortByAll(users, ['user', 'age']), _.values); |
| * // => [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]] |
| * |
| * _.map(_.sortByAll(users, 'user', function(chr) { |
| * return Math.floor(chr.age / 10); |
| * }), _.values); |
| * // => [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] |
| */ |
| var sortByAll = restParam(function (collection, iteratees) { |
| if (collection == null) { |
| return []; |
| } |
| var guard = iteratees[2]; |
| if (guard && isIterateeCall(iteratees[0], iteratees[1], guard)) { |
| iteratees.length = 1; |
| } |
| return baseSortByOrder(collection, baseFlatten(iteratees), []); |
| }); |
| /** |
| * This method is like `_.sortByAll` except that it allows specifying the |
| * sort orders of the iteratees to sort by. If `orders` is unspecified, all |
| * values are sorted in ascending order. Otherwise, a value is sorted in |
| * ascending order if its corresponding order is "asc", and descending if "desc". |
| * |
| * If a property name is provided for an iteratee the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If an object is provided for an iteratee the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. |
| * @param {boolean[]} [orders] The sort orders of `iteratees`. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`. |
| * @returns {Array} Returns the new sorted array. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'fred', 'age': 48 }, |
| * { 'user': 'barney', 'age': 34 }, |
| * { 'user': 'fred', 'age': 42 }, |
| * { 'user': 'barney', 'age': 36 } |
| * ]; |
| * |
| * // sort by `user` in ascending order and by `age` in descending order |
| * _.map(_.sortByOrder(users, ['user', 'age'], ['asc', 'desc']), _.values); |
| * // => [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] |
| */ |
| function sortByOrder(collection, iteratees, orders, guard) { |
| if (collection == null) { |
| return []; |
| } |
| if (guard && isIterateeCall(iteratees, orders, guard)) { |
| orders = undefined; |
| } |
| if (!isArray(iteratees)) { |
| iteratees = iteratees == null ? [] : [iteratees]; |
| } |
| if (!isArray(orders)) { |
| orders = orders == null ? [] : [orders]; |
| } |
| return baseSortByOrder(collection, iteratees, orders); |
| } |
| /** |
| * Performs a deep comparison between each element in `collection` and the |
| * source object, returning an array of all elements that have equivalent |
| * property values. |
| * |
| * **Note:** This method supports comparing arrays, booleans, `Date` objects, |
| * numbers, `Object` objects, regexes, and strings. Objects are compared by |
| * their own, not inherited, enumerable properties. For comparing a single |
| * own or inherited property value see `_.matchesProperty`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Collection |
| * @param {Array|Object|string} collection The collection to search. |
| * @param {Object} source The object of property values to match. |
| * @returns {Array} Returns the new filtered array. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': false, 'pets': ['hoppy'] }, |
| * { 'user': 'fred', 'age': 40, 'active': true, 'pets': ['baby puss', 'dino'] } |
| * ]; |
| * |
| * _.pluck(_.where(users, { 'age': 36, 'active': false }), 'user'); |
| * // => ['barney'] |
| * |
| * _.pluck(_.where(users, { 'pets': ['dino'] }), 'user'); |
| * // => ['fred'] |
| */ |
| function where(collection, source) { |
| return filter(collection, baseMatches(source)); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Gets the number of milliseconds that have elapsed since the Unix epoch |
| * (1 January 1970 00:00:00 UTC). |
| * |
| * @static |
| * @memberOf _ |
| * @category Date |
| * @example |
| * |
| * _.defer(function(stamp) { |
| * console.log(_.now() - stamp); |
| * }, _.now()); |
| * // => logs the number of milliseconds it took for the deferred function to be invoked |
| */ |
| var now = nativeNow || function () { |
| return new Date().getTime(); |
| }; |
| /*------------------------------------------------------------------------*/ |
| /** |
| * The opposite of `_.before`; this method creates a function that invokes |
| * `func` once it's called `n` or more times. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {number} n The number of calls before `func` is invoked. |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * var saves = ['profile', 'settings']; |
| * |
| * var done = _.after(saves.length, function() { |
| * console.log('done saving!'); |
| * }); |
| * |
| * _.forEach(saves, function(type) { |
| * asyncSave({ 'type': type, 'complete': done }); |
| * }); |
| * // => logs 'done saving!' after the two async saves have completed |
| */ |
| function after(n, func) { |
| if (typeof func != 'function') { |
| if (typeof n == 'function') { |
| var temp = n; |
| n = func; |
| func = temp; |
| } else { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| } |
| n = nativeIsFinite(n = +n) ? n : 0; |
| return function () { |
| if (--n < 1) { |
| return func.apply(this, arguments); |
| } |
| }; |
| } |
| /** |
| * Creates a function that accepts up to `n` arguments ignoring any |
| * additional arguments. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to cap arguments for. |
| * @param {number} [n=func.length] The arity cap. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * _.map(['6', '8', '10'], _.ary(parseInt, 1)); |
| * // => [6, 8, 10] |
| */ |
| function ary(func, n, guard) { |
| if (guard && isIterateeCall(func, n, guard)) { |
| n = undefined; |
| } |
| n = func && n == null ? func.length : nativeMax(+n || 0, 0); |
| return createWrapper(func, ARY_FLAG, undefined, undefined, undefined, undefined, n); |
| } |
| /** |
| * Creates a function that invokes `func`, with the `this` binding and arguments |
| * of the created function, while it's called less than `n` times. Subsequent |
| * calls to the created function return the result of the last `func` invocation. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {number} n The number of calls at which `func` is no longer invoked. |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * jQuery('#add').on('click', _.before(5, addContactToList)); |
| * // => allows adding up to 4 contacts to the list |
| */ |
| function before(n, func) { |
| var result; |
| if (typeof func != 'function') { |
| if (typeof n == 'function') { |
| var temp = n; |
| n = func; |
| func = temp; |
| } else { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| } |
| return function () { |
| if (--n > 0) { |
| result = func.apply(this, arguments); |
| } |
| if (n <= 1) { |
| func = undefined; |
| } |
| return result; |
| }; |
| } |
| /** |
| * Creates a function that invokes `func` with the `this` binding of `thisArg` |
| * and prepends any additional `_.bind` arguments to those provided to the |
| * bound function. |
| * |
| * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, |
| * may be used as a placeholder for partially applied arguments. |
| * |
| * **Note:** Unlike native `Function#bind` this method does not set the "length" |
| * property of bound functions. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to bind. |
| * @param {*} thisArg The `this` binding of `func`. |
| * @param {...*} [partials] The arguments to be partially applied. |
| * @returns {Function} Returns the new bound function. |
| * @example |
| * |
| * var greet = function(greeting, punctuation) { |
| * return greeting + ' ' + this.user + punctuation; |
| * }; |
| * |
| * var object = { 'user': 'fred' }; |
| * |
| * var bound = _.bind(greet, object, 'hi'); |
| * bound('!'); |
| * // => 'hi fred!' |
| * |
| * // using placeholders |
| * var bound = _.bind(greet, object, _, '!'); |
| * bound('hi'); |
| * // => 'hi fred!' |
| */ |
| var bind = restParam(function (func, thisArg, partials) { |
| var bitmask = BIND_FLAG; |
| if (partials.length) { |
| var holders = replaceHolders(partials, bind.placeholder); |
| bitmask |= PARTIAL_FLAG; |
| } |
| return createWrapper(func, bitmask, thisArg, partials, holders); |
| }); |
| /** |
| * Binds methods of an object to the object itself, overwriting the existing |
| * method. Method names may be specified as individual arguments or as arrays |
| * of method names. If no method names are provided all enumerable function |
| * properties, own and inherited, of `object` are bound. |
| * |
| * **Note:** This method does not set the "length" property of bound functions. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Object} object The object to bind and assign the bound methods to. |
| * @param {...(string|string[])} [methodNames] The object method names to bind, |
| * specified as individual method names or arrays of method names. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * var view = { |
| * 'label': 'docs', |
| * 'onClick': function() { |
| * console.log('clicked ' + this.label); |
| * } |
| * }; |
| * |
| * _.bindAll(view); |
| * jQuery('#docs').on('click', view.onClick); |
| * // => logs 'clicked docs' when the element is clicked |
| */ |
| var bindAll = restParam(function (object, methodNames) { |
| methodNames = methodNames.length ? baseFlatten(methodNames) : functions(object); |
| var index = -1, length = methodNames.length; |
| while (++index < length) { |
| var key = methodNames[index]; |
| object[key] = createWrapper(object[key], BIND_FLAG, object); |
| } |
| return object; |
| }); |
| /** |
| * Creates a function that invokes the method at `object[key]` and prepends |
| * any additional `_.bindKey` arguments to those provided to the bound function. |
| * |
| * This method differs from `_.bind` by allowing bound functions to reference |
| * methods that may be redefined or don't yet exist. |
| * See [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) |
| * for more details. |
| * |
| * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic |
| * builds, may be used as a placeholder for partially applied arguments. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Object} object The object the method belongs to. |
| * @param {string} key The key of the method. |
| * @param {...*} [partials] The arguments to be partially applied. |
| * @returns {Function} Returns the new bound function. |
| * @example |
| * |
| * var object = { |
| * 'user': 'fred', |
| * 'greet': function(greeting, punctuation) { |
| * return greeting + ' ' + this.user + punctuation; |
| * } |
| * }; |
| * |
| * var bound = _.bindKey(object, 'greet', 'hi'); |
| * bound('!'); |
| * // => 'hi fred!' |
| * |
| * object.greet = function(greeting, punctuation) { |
| * return greeting + 'ya ' + this.user + punctuation; |
| * }; |
| * |
| * bound('!'); |
| * // => 'hiya fred!' |
| * |
| * // using placeholders |
| * var bound = _.bindKey(object, 'greet', _, '!'); |
| * bound('hi'); |
| * // => 'hiya fred!' |
| */ |
| var bindKey = restParam(function (object, key, partials) { |
| var bitmask = BIND_FLAG | BIND_KEY_FLAG; |
| if (partials.length) { |
| var holders = replaceHolders(partials, bindKey.placeholder); |
| bitmask |= PARTIAL_FLAG; |
| } |
| return createWrapper(key, bitmask, object, partials, holders); |
| }); |
| /** |
| * Creates a function that accepts one or more arguments of `func` that when |
| * called either invokes `func` returning its result, if all `func` arguments |
| * have been provided, or returns a function that accepts one or more of the |
| * remaining `func` arguments, and so on. The arity of `func` may be specified |
| * if `func.length` is not sufficient. |
| * |
| * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, |
| * may be used as a placeholder for provided arguments. |
| * |
| * **Note:** This method does not set the "length" property of curried functions. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to curry. |
| * @param {number} [arity=func.length] The arity of `func`. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Function} Returns the new curried function. |
| * @example |
| * |
| * var abc = function(a, b, c) { |
| * return [a, b, c]; |
| * }; |
| * |
| * var curried = _.curry(abc); |
| * |
| * curried(1)(2)(3); |
| * // => [1, 2, 3] |
| * |
| * curried(1, 2)(3); |
| * // => [1, 2, 3] |
| * |
| * curried(1, 2, 3); |
| * // => [1, 2, 3] |
| * |
| * // using placeholders |
| * curried(1)(_, 3)(2); |
| * // => [1, 2, 3] |
| */ |
| var curry = createCurry(CURRY_FLAG); |
| /** |
| * This method is like `_.curry` except that arguments are applied to `func` |
| * in the manner of `_.partialRight` instead of `_.partial`. |
| * |
| * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic |
| * builds, may be used as a placeholder for provided arguments. |
| * |
| * **Note:** This method does not set the "length" property of curried functions. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to curry. |
| * @param {number} [arity=func.length] The arity of `func`. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Function} Returns the new curried function. |
| * @example |
| * |
| * var abc = function(a, b, c) { |
| * return [a, b, c]; |
| * }; |
| * |
| * var curried = _.curryRight(abc); |
| * |
| * curried(3)(2)(1); |
| * // => [1, 2, 3] |
| * |
| * curried(2, 3)(1); |
| * // => [1, 2, 3] |
| * |
| * curried(1, 2, 3); |
| * // => [1, 2, 3] |
| * |
| * // using placeholders |
| * curried(3)(1, _)(2); |
| * // => [1, 2, 3] |
| */ |
| var curryRight = createCurry(CURRY_RIGHT_FLAG); |
| /** |
| * Creates a debounced function that delays invoking `func` until after `wait` |
| * milliseconds have elapsed since the last time the debounced function was |
| * invoked. The debounced function comes with a `cancel` method to cancel |
| * delayed invocations. Provide an options object to indicate that `func` |
| * should be invoked on the leading and/or trailing edge of the `wait` timeout. |
| * Subsequent calls to the debounced function return the result of the last |
| * `func` invocation. |
| * |
| * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked |
| * on the trailing edge of the timeout only if the the debounced function is |
| * invoked more than once during the `wait` timeout. |
| * |
| * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation) |
| * for details over the differences between `_.debounce` and `_.throttle`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to debounce. |
| * @param {number} [wait=0] The number of milliseconds to delay. |
| * @param {Object} [options] The options object. |
| * @param {boolean} [options.leading=false] Specify invoking on the leading |
| * edge of the timeout. |
| * @param {number} [options.maxWait] The maximum time `func` is allowed to be |
| * delayed before it's invoked. |
| * @param {boolean} [options.trailing=true] Specify invoking on the trailing |
| * edge of the timeout. |
| * @returns {Function} Returns the new debounced function. |
| * @example |
| * |
| * // avoid costly calculations while the window size is in flux |
| * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); |
| * |
| * // invoke `sendMail` when the click event is fired, debouncing subsequent calls |
| * jQuery('#postbox').on('click', _.debounce(sendMail, 300, { |
| * 'leading': true, |
| * 'trailing': false |
| * })); |
| * |
| * // ensure `batchLog` is invoked once after 1 second of debounced calls |
| * var source = new EventSource('/stream'); |
| * jQuery(source).on('message', _.debounce(batchLog, 250, { |
| * 'maxWait': 1000 |
| * })); |
| * |
| * // cancel a debounced call |
| * var todoChanges = _.debounce(batchLog, 1000); |
| * Object.observe(models.todo, todoChanges); |
| * |
| * Object.observe(models, function(changes) { |
| * if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) { |
| * todoChanges.cancel(); |
| * } |
| * }, ['delete']); |
| * |
| * // ...at some point `models.todo` is changed |
| * models.todo.completed = true; |
| * |
| * // ...before 1 second has passed `models.todo` is deleted |
| * // which cancels the debounced `todoChanges` call |
| * delete models.todo; |
| */ |
| function debounce(func, wait, options) { |
| var args, maxTimeoutId, result, stamp, thisArg, timeoutId, trailingCall, lastCalled = 0, maxWait = false, trailing = true; |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| wait = wait < 0 ? 0 : +wait || 0; |
| if (options === true) { |
| var leading = true; |
| trailing = false; |
| } else if (isObject(options)) { |
| leading = !!options.leading; |
| maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait); |
| trailing = 'trailing' in options ? !!options.trailing : trailing; |
| } |
| function cancel() { |
| if (timeoutId) { |
| clearTimeout(timeoutId); |
| } |
| if (maxTimeoutId) { |
| clearTimeout(maxTimeoutId); |
| } |
| lastCalled = 0; |
| maxTimeoutId = timeoutId = trailingCall = undefined; |
| } |
| function complete(isCalled, id) { |
| if (id) { |
| clearTimeout(id); |
| } |
| maxTimeoutId = timeoutId = trailingCall = undefined; |
| if (isCalled) { |
| lastCalled = now(); |
| result = func.apply(thisArg, args); |
| if (!timeoutId && !maxTimeoutId) { |
| args = thisArg = undefined; |
| } |
| } |
| } |
| function delayed() { |
| var remaining = wait - (now() - stamp); |
| if (remaining <= 0 || remaining > wait) { |
| complete(trailingCall, maxTimeoutId); |
| } else { |
| timeoutId = setTimeout(delayed, remaining); |
| } |
| } |
| function maxDelayed() { |
| complete(trailing, timeoutId); |
| } |
| function debounced() { |
| args = arguments; |
| stamp = now(); |
| thisArg = this; |
| trailingCall = trailing && (timeoutId || !leading); |
| if (maxWait === false) { |
| var leadingCall = leading && !timeoutId; |
| } else { |
| if (!maxTimeoutId && !leading) { |
| lastCalled = stamp; |
| } |
| var remaining = maxWait - (stamp - lastCalled), isCalled = remaining <= 0 || remaining > maxWait; |
| if (isCalled) { |
| if (maxTimeoutId) { |
| maxTimeoutId = clearTimeout(maxTimeoutId); |
| } |
| lastCalled = stamp; |
| result = func.apply(thisArg, args); |
| } else if (!maxTimeoutId) { |
| maxTimeoutId = setTimeout(maxDelayed, remaining); |
| } |
| } |
| if (isCalled && timeoutId) { |
| timeoutId = clearTimeout(timeoutId); |
| } else if (!timeoutId && wait !== maxWait) { |
| timeoutId = setTimeout(delayed, wait); |
| } |
| if (leadingCall) { |
| isCalled = true; |
| result = func.apply(thisArg, args); |
| } |
| if (isCalled && !timeoutId && !maxTimeoutId) { |
| args = thisArg = undefined; |
| } |
| return result; |
| } |
| debounced.cancel = cancel; |
| return debounced; |
| } |
| /** |
| * Defers invoking the `func` until the current call stack has cleared. Any |
| * additional arguments are provided to `func` when it's invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to defer. |
| * @param {...*} [args] The arguments to invoke the function with. |
| * @returns {number} Returns the timer id. |
| * @example |
| * |
| * _.defer(function(text) { |
| * console.log(text); |
| * }, 'deferred'); |
| * // logs 'deferred' after one or more milliseconds |
| */ |
| var defer = restParam(function (func, args) { |
| return baseDelay(func, 1, args); |
| }); |
| /** |
| * Invokes `func` after `wait` milliseconds. Any additional arguments are |
| * provided to `func` when it's invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to delay. |
| * @param {number} wait The number of milliseconds to delay invocation. |
| * @param {...*} [args] The arguments to invoke the function with. |
| * @returns {number} Returns the timer id. |
| * @example |
| * |
| * _.delay(function(text) { |
| * console.log(text); |
| * }, 1000, 'later'); |
| * // => logs 'later' after one second |
| */ |
| var delay = restParam(function (func, wait, args) { |
| return baseDelay(func, wait, args); |
| }); |
| /** |
| * Creates a function that returns the result of invoking the provided |
| * functions with the `this` binding of the created function, where each |
| * successive invocation is supplied the return value of the previous. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {...Function} [funcs] Functions to invoke. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * function square(n) { |
| * return n * n; |
| * } |
| * |
| * var addSquare = _.flow(_.add, square); |
| * addSquare(1, 2); |
| * // => 9 |
| */ |
| var flow = createFlow(); |
| /** |
| * This method is like `_.flow` except that it creates a function that |
| * invokes the provided functions from right to left. |
| * |
| * @static |
| * @memberOf _ |
| * @alias backflow, compose |
| * @category Function |
| * @param {...Function} [funcs] Functions to invoke. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * function square(n) { |
| * return n * n; |
| * } |
| * |
| * var addSquare = _.flowRight(square, _.add); |
| * addSquare(1, 2); |
| * // => 9 |
| */ |
| var flowRight = createFlow(true); |
| /** |
| * Creates a function that memoizes the result of `func`. If `resolver` is |
| * provided it determines the cache key for storing the result based on the |
| * arguments provided to the memoized function. By default, the first argument |
| * provided to the memoized function is coerced to a string and used as the |
| * cache key. The `func` is invoked with the `this` binding of the memoized |
| * function. |
| * |
| * **Note:** The cache is exposed as the `cache` property on the memoized |
| * function. Its creation may be customized by replacing the `_.memoize.Cache` |
| * constructor with one whose instances implement the [`Map`](http://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-map-prototype-object) |
| * method interface of `get`, `has`, and `set`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to have its output memoized. |
| * @param {Function} [resolver] The function to resolve the cache key. |
| * @returns {Function} Returns the new memoizing function. |
| * @example |
| * |
| * var upperCase = _.memoize(function(string) { |
| * return string.toUpperCase(); |
| * }); |
| * |
| * upperCase('fred'); |
| * // => 'FRED' |
| * |
| * // modifying the result cache |
| * upperCase.cache.set('fred', 'BARNEY'); |
| * upperCase('fred'); |
| * // => 'BARNEY' |
| * |
| * // replacing `_.memoize.Cache` |
| * var object = { 'user': 'fred' }; |
| * var other = { 'user': 'barney' }; |
| * var identity = _.memoize(_.identity); |
| * |
| * identity(object); |
| * // => { 'user': 'fred' } |
| * identity(other); |
| * // => { 'user': 'fred' } |
| * |
| * _.memoize.Cache = WeakMap; |
| * var identity = _.memoize(_.identity); |
| * |
| * identity(object); |
| * // => { 'user': 'fred' } |
| * identity(other); |
| * // => { 'user': 'barney' } |
| */ |
| function memoize(func, resolver) { |
| if (typeof func != 'function' || resolver && typeof resolver != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| var memoized = function () { |
| var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache; |
| if (cache.has(key)) { |
| return cache.get(key); |
| } |
| var result = func.apply(this, args); |
| memoized.cache = cache.set(key, result); |
| return result; |
| }; |
| memoized.cache = new memoize.Cache(); |
| return memoized; |
| } |
| /** |
| * Creates a function that runs each argument through a corresponding |
| * transform function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to wrap. |
| * @param {...(Function|Function[])} [transforms] The functions to transform |
| * arguments, specified as individual functions or arrays of functions. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * function doubled(n) { |
| * return n * 2; |
| * } |
| * |
| * function square(n) { |
| * return n * n; |
| * } |
| * |
| * var modded = _.modArgs(function(x, y) { |
| * return [x, y]; |
| * }, square, doubled); |
| * |
| * modded(1, 2); |
| * // => [1, 4] |
| * |
| * modded(5, 10); |
| * // => [25, 20] |
| */ |
| var modArgs = restParam(function (func, transforms) { |
| transforms = baseFlatten(transforms); |
| if (typeof func != 'function' || !arrayEvery(transforms, baseIsFunction)) { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| var length = transforms.length; |
| return restParam(function (args) { |
| var index = nativeMin(args.length, length); |
| while (index--) { |
| args[index] = transforms[index](args[index]); |
| } |
| return func.apply(this, args); |
| }); |
| }); |
| /** |
| * Creates a function that negates the result of the predicate `func`. The |
| * `func` predicate is invoked with the `this` binding and arguments of the |
| * created function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} predicate The predicate to negate. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * function isEven(n) { |
| * return n % 2 == 0; |
| * } |
| * |
| * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); |
| * // => [1, 3, 5] |
| */ |
| function negate(predicate) { |
| if (typeof predicate != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| return function () { |
| return !predicate.apply(this, arguments); |
| }; |
| } |
| /** |
| * Creates a function that is restricted to invoking `func` once. Repeat calls |
| * to the function return the value of the first call. The `func` is invoked |
| * with the `this` binding and arguments of the created function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to restrict. |
| * @returns {Function} Returns the new restricted function. |
| * @example |
| * |
| * var initialize = _.once(createApplication); |
| * initialize(); |
| * initialize(); |
| * // `initialize` invokes `createApplication` once |
| */ |
| function once(func) { |
| return before(2, func); |
| } |
| /** |
| * Creates a function that invokes `func` with `partial` arguments prepended |
| * to those provided to the new function. This method is like `_.bind` except |
| * it does **not** alter the `this` binding. |
| * |
| * The `_.partial.placeholder` value, which defaults to `_` in monolithic |
| * builds, may be used as a placeholder for partially applied arguments. |
| * |
| * **Note:** This method does not set the "length" property of partially |
| * applied functions. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to partially apply arguments to. |
| * @param {...*} [partials] The arguments to be partially applied. |
| * @returns {Function} Returns the new partially applied function. |
| * @example |
| * |
| * var greet = function(greeting, name) { |
| * return greeting + ' ' + name; |
| * }; |
| * |
| * var sayHelloTo = _.partial(greet, 'hello'); |
| * sayHelloTo('fred'); |
| * // => 'hello fred' |
| * |
| * // using placeholders |
| * var greetFred = _.partial(greet, _, 'fred'); |
| * greetFred('hi'); |
| * // => 'hi fred' |
| */ |
| var partial = createPartial(PARTIAL_FLAG); |
| /** |
| * This method is like `_.partial` except that partially applied arguments |
| * are appended to those provided to the new function. |
| * |
| * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic |
| * builds, may be used as a placeholder for partially applied arguments. |
| * |
| * **Note:** This method does not set the "length" property of partially |
| * applied functions. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to partially apply arguments to. |
| * @param {...*} [partials] The arguments to be partially applied. |
| * @returns {Function} Returns the new partially applied function. |
| * @example |
| * |
| * var greet = function(greeting, name) { |
| * return greeting + ' ' + name; |
| * }; |
| * |
| * var greetFred = _.partialRight(greet, 'fred'); |
| * greetFred('hi'); |
| * // => 'hi fred' |
| * |
| * // using placeholders |
| * var sayHelloTo = _.partialRight(greet, 'hello', _); |
| * sayHelloTo('fred'); |
| * // => 'hello fred' |
| */ |
| var partialRight = createPartial(PARTIAL_RIGHT_FLAG); |
| /** |
| * Creates a function that invokes `func` with arguments arranged according |
| * to the specified indexes where the argument value at the first index is |
| * provided as the first argument, the argument value at the second index is |
| * provided as the second argument, and so on. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to rearrange arguments for. |
| * @param {...(number|number[])} indexes The arranged argument indexes, |
| * specified as individual indexes or arrays of indexes. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var rearged = _.rearg(function(a, b, c) { |
| * return [a, b, c]; |
| * }, 2, 0, 1); |
| * |
| * rearged('b', 'c', 'a') |
| * // => ['a', 'b', 'c'] |
| * |
| * var map = _.rearg(_.map, [1, 0]); |
| * map(function(n) { |
| * return n * 3; |
| * }, [1, 2, 3]); |
| * // => [3, 6, 9] |
| */ |
| var rearg = restParam(function (func, indexes) { |
| return createWrapper(func, REARG_FLAG, undefined, undefined, undefined, baseFlatten(indexes)); |
| }); |
| /** |
| * Creates a function that invokes `func` with the `this` binding of the |
| * created function and arguments from `start` and beyond provided as an array. |
| * |
| * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters). |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to apply a rest parameter to. |
| * @param {number} [start=func.length-1] The start position of the rest parameter. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var say = _.restParam(function(what, names) { |
| * return what + ' ' + _.initial(names).join(', ') + |
| * (_.size(names) > 1 ? ', & ' : '') + _.last(names); |
| * }); |
| * |
| * say('hello', 'fred', 'barney', 'pebbles'); |
| * // => 'hello fred, barney, & pebbles' |
| */ |
| function restParam(func, start) { |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| start = nativeMax(start === undefined ? func.length - 1 : +start || 0, 0); |
| return function () { |
| var args = arguments, index = -1, length = nativeMax(args.length - start, 0), rest = Array(length); |
| while (++index < length) { |
| rest[index] = args[start + index]; |
| } |
| switch (start) { |
| case 0: |
| return func.call(this, rest); |
| case 1: |
| return func.call(this, args[0], rest); |
| case 2: |
| return func.call(this, args[0], args[1], rest); |
| } |
| var otherArgs = Array(start + 1); |
| index = -1; |
| while (++index < start) { |
| otherArgs[index] = args[index]; |
| } |
| otherArgs[start] = rest; |
| return func.apply(this, otherArgs); |
| }; |
| } |
| /** |
| * Creates a function that invokes `func` with the `this` binding of the created |
| * function and an array of arguments much like [`Function#apply`](https://es5.github.io/#x15.3.4.3). |
| * |
| * **Note:** This method is based on the [spread operator](https://developer.mozilla.org/Web/JavaScript/Reference/Operators/Spread_operator). |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to spread arguments over. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var say = _.spread(function(who, what) { |
| * return who + ' says ' + what; |
| * }); |
| * |
| * say(['fred', 'hello']); |
| * // => 'fred says hello' |
| * |
| * // with a Promise |
| * var numbers = Promise.all([ |
| * Promise.resolve(40), |
| * Promise.resolve(36) |
| * ]); |
| * |
| * numbers.then(_.spread(function(x, y) { |
| * return x + y; |
| * })); |
| * // => a Promise of 76 |
| */ |
| function spread(func) { |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| return function (array) { |
| return func.apply(this, array); |
| }; |
| } |
| /** |
| * Creates a throttled function that only invokes `func` at most once per |
| * every `wait` milliseconds. The throttled function comes with a `cancel` |
| * method to cancel delayed invocations. Provide an options object to indicate |
| * that `func` should be invoked on the leading and/or trailing edge of the |
| * `wait` timeout. Subsequent calls to the throttled function return the |
| * result of the last `func` call. |
| * |
| * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked |
| * on the trailing edge of the timeout only if the the throttled function is |
| * invoked more than once during the `wait` timeout. |
| * |
| * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation) |
| * for details over the differences between `_.throttle` and `_.debounce`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {Function} func The function to throttle. |
| * @param {number} [wait=0] The number of milliseconds to throttle invocations to. |
| * @param {Object} [options] The options object. |
| * @param {boolean} [options.leading=true] Specify invoking on the leading |
| * edge of the timeout. |
| * @param {boolean} [options.trailing=true] Specify invoking on the trailing |
| * edge of the timeout. |
| * @returns {Function} Returns the new throttled function. |
| * @example |
| * |
| * // avoid excessively updating the position while scrolling |
| * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); |
| * |
| * // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes |
| * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, { |
| * 'trailing': false |
| * })); |
| * |
| * // cancel a trailing throttled call |
| * jQuery(window).on('popstate', throttled.cancel); |
| */ |
| function throttle(func, wait, options) { |
| var leading = true, trailing = true; |
| if (typeof func != 'function') { |
| throw new TypeError(FUNC_ERROR_TEXT); |
| } |
| if (options === false) { |
| leading = false; |
| } else if (isObject(options)) { |
| leading = 'leading' in options ? !!options.leading : leading; |
| trailing = 'trailing' in options ? !!options.trailing : trailing; |
| } |
| return debounce(func, wait, { |
| 'leading': leading, |
| 'maxWait': +wait, |
| 'trailing': trailing |
| }); |
| } |
| /** |
| * Creates a function that provides `value` to the wrapper function as its |
| * first argument. Any additional arguments provided to the function are |
| * appended to those provided to the wrapper function. The wrapper is invoked |
| * with the `this` binding of the created function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Function |
| * @param {*} value The value to wrap. |
| * @param {Function} wrapper The wrapper function. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var p = _.wrap(_.escape, function(func, text) { |
| * return '<p>' + func(text) + '</p>'; |
| * }); |
| * |
| * p('fred, barney, & pebbles'); |
| * // => '<p>fred, barney, & pebbles</p>' |
| */ |
| function wrap(value, wrapper) { |
| wrapper = wrapper == null ? identity : wrapper; |
| return createWrapper(wrapper, PARTIAL_FLAG, undefined, [value], []); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned, |
| * otherwise they are assigned by reference. If `customizer` is provided it's |
| * invoked to produce the cloned values. If `customizer` returns `undefined` |
| * cloning is handled by the method instead. The `customizer` is bound to |
| * `thisArg` and invoked with up to three argument; (value [, index|key, object]). |
| * |
| * **Note:** This method is loosely based on the |
| * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm). |
| * The enumerable properties of `arguments` objects and objects created by |
| * constructors other than `Object` are cloned to plain `Object` objects. An |
| * empty object is returned for uncloneable values such as functions, DOM nodes, |
| * Maps, Sets, and WeakMaps. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to clone. |
| * @param {boolean} [isDeep] Specify a deep clone. |
| * @param {Function} [customizer] The function to customize cloning values. |
| * @param {*} [thisArg] The `this` binding of `customizer`. |
| * @returns {*} Returns the cloned value. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney' }, |
| * { 'user': 'fred' } |
| * ]; |
| * |
| * var shallow = _.clone(users); |
| * shallow[0] === users[0]; |
| * // => true |
| * |
| * var deep = _.clone(users, true); |
| * deep[0] === users[0]; |
| * // => false |
| * |
| * // using a customizer callback |
| * var el = _.clone(document.body, function(value) { |
| * if (_.isElement(value)) { |
| * return value.cloneNode(false); |
| * } |
| * }); |
| * |
| * el === document.body |
| * // => false |
| * el.nodeName |
| * // => BODY |
| * el.childNodes.length; |
| * // => 0 |
| */ |
| function clone(value, isDeep, customizer, thisArg) { |
| if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) { |
| isDeep = false; |
| } else if (typeof isDeep == 'function') { |
| thisArg = customizer; |
| customizer = isDeep; |
| isDeep = false; |
| } |
| return typeof customizer == 'function' ? baseClone(value, isDeep, bindCallback(customizer, thisArg, 3)) : baseClone(value, isDeep); |
| } |
| /** |
| * Creates a deep clone of `value`. If `customizer` is provided it's invoked |
| * to produce the cloned values. If `customizer` returns `undefined` cloning |
| * is handled by the method instead. The `customizer` is bound to `thisArg` |
| * and invoked with up to three argument; (value [, index|key, object]). |
| * |
| * **Note:** This method is loosely based on the |
| * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm). |
| * The enumerable properties of `arguments` objects and objects created by |
| * constructors other than `Object` are cloned to plain `Object` objects. An |
| * empty object is returned for uncloneable values such as functions, DOM nodes, |
| * Maps, Sets, and WeakMaps. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to deep clone. |
| * @param {Function} [customizer] The function to customize cloning values. |
| * @param {*} [thisArg] The `this` binding of `customizer`. |
| * @returns {*} Returns the deep cloned value. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney' }, |
| * { 'user': 'fred' } |
| * ]; |
| * |
| * var deep = _.cloneDeep(users); |
| * deep[0] === users[0]; |
| * // => false |
| * |
| * // using a customizer callback |
| * var el = _.cloneDeep(document.body, function(value) { |
| * if (_.isElement(value)) { |
| * return value.cloneNode(true); |
| * } |
| * }); |
| * |
| * el === document.body |
| * // => false |
| * el.nodeName |
| * // => BODY |
| * el.childNodes.length; |
| * // => 20 |
| */ |
| function cloneDeep(value, customizer, thisArg) { |
| return typeof customizer == 'function' ? baseClone(value, true, bindCallback(customizer, thisArg, 3)) : baseClone(value, true); |
| } |
| /** |
| * Checks if `value` is greater than `other`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if `value` is greater than `other`, else `false`. |
| * @example |
| * |
| * _.gt(3, 1); |
| * // => true |
| * |
| * _.gt(3, 3); |
| * // => false |
| * |
| * _.gt(1, 3); |
| * // => false |
| */ |
| function gt(value, other) { |
| return value > other; |
| } |
| /** |
| * Checks if `value` is greater than or equal to `other`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if `value` is greater than or equal to `other`, else `false`. |
| * @example |
| * |
| * _.gte(3, 1); |
| * // => true |
| * |
| * _.gte(3, 3); |
| * // => true |
| * |
| * _.gte(1, 3); |
| * // => false |
| */ |
| function gte(value, other) { |
| return value >= other; |
| } |
| /** |
| * Checks if `value` is classified as an `arguments` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isArguments(function() { return arguments; }()); |
| * // => true |
| * |
| * _.isArguments([1, 2, 3]); |
| * // => false |
| */ |
| function isArguments(value) { |
| return isObjectLike(value) && isArrayLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee'); |
| } |
| /** |
| * Checks if `value` is classified as an `Array` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isArray([1, 2, 3]); |
| * // => true |
| * |
| * _.isArray(function() { return arguments; }()); |
| * // => false |
| */ |
| var isArray = nativeIsArray || function (value) { |
| return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag; |
| }; |
| /** |
| * Checks if `value` is classified as a boolean primitive or object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isBoolean(false); |
| * // => true |
| * |
| * _.isBoolean(null); |
| * // => false |
| */ |
| function isBoolean(value) { |
| return value === true || value === false || isObjectLike(value) && objToString.call(value) == boolTag; |
| } |
| /** |
| * Checks if `value` is classified as a `Date` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isDate(new Date); |
| * // => true |
| * |
| * _.isDate('Mon April 23 2012'); |
| * // => false |
| */ |
| function isDate(value) { |
| return isObjectLike(value) && objToString.call(value) == dateTag; |
| } |
| /** |
| * Checks if `value` is a DOM element. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. |
| * @example |
| * |
| * _.isElement(document.body); |
| * // => true |
| * |
| * _.isElement('<body>'); |
| * // => false |
| */ |
| function isElement(value) { |
| return !!value && value.nodeType === 1 && isObjectLike(value) && !isPlainObject(value); |
| } |
| /** |
| * Checks if `value` is empty. A value is considered empty unless it's an |
| * `arguments` object, array, string, or jQuery-like collection with a length |
| * greater than `0` or an object with own enumerable properties. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {Array|Object|string} value The value to inspect. |
| * @returns {boolean} Returns `true` if `value` is empty, else `false`. |
| * @example |
| * |
| * _.isEmpty(null); |
| * // => true |
| * |
| * _.isEmpty(true); |
| * // => true |
| * |
| * _.isEmpty(1); |
| * // => true |
| * |
| * _.isEmpty([1, 2, 3]); |
| * // => false |
| * |
| * _.isEmpty({ 'a': 1 }); |
| * // => false |
| */ |
| function isEmpty(value) { |
| if (value == null) { |
| return true; |
| } |
| if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) || isObjectLike(value) && isFunction(value.splice))) { |
| return !value.length; |
| } |
| return !keys(value).length; |
| } |
| /** |
| * Performs a deep comparison between two values to determine if they are |
| * equivalent. If `customizer` is provided it's invoked to compare values. |
| * If `customizer` returns `undefined` comparisons are handled by the method |
| * instead. The `customizer` is bound to `thisArg` and invoked with up to |
| * three arguments: (value, other [, index|key]). |
| * |
| * **Note:** This method supports comparing arrays, booleans, `Date` objects, |
| * numbers, `Object` objects, regexes, and strings. Objects are compared by |
| * their own, not inherited, enumerable properties. Functions and DOM nodes |
| * are **not** supported. Provide a customizer function to extend support |
| * for comparing other values. |
| * |
| * @static |
| * @memberOf _ |
| * @alias eq |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @param {Function} [customizer] The function to customize value comparisons. |
| * @param {*} [thisArg] The `this` binding of `customizer`. |
| * @returns {boolean} Returns `true` if the values are equivalent, else `false`. |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * var other = { 'user': 'fred' }; |
| * |
| * object == other; |
| * // => false |
| * |
| * _.isEqual(object, other); |
| * // => true |
| * |
| * // using a customizer callback |
| * var array = ['hello', 'goodbye']; |
| * var other = ['hi', 'goodbye']; |
| * |
| * _.isEqual(array, other, function(value, other) { |
| * if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) { |
| * return true; |
| * } |
| * }); |
| * // => true |
| */ |
| function isEqual(value, other, customizer, thisArg) { |
| customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined; |
| var result = customizer ? customizer(value, other) : undefined; |
| return result === undefined ? baseIsEqual(value, other, customizer) : !!result; |
| } |
| /** |
| * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, |
| * `SyntaxError`, `TypeError`, or `URIError` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an error object, else `false`. |
| * @example |
| * |
| * _.isError(new Error); |
| * // => true |
| * |
| * _.isError(Error); |
| * // => false |
| */ |
| function isError(value) { |
| return isObjectLike(value) && typeof value.message == 'string' && objToString.call(value) == errorTag; |
| } |
| /** |
| * Checks if `value` is a finite primitive number. |
| * |
| * **Note:** This method is based on [`Number.isFinite`](http://ecma-international.org/ecma-262/6.0/#sec-number.isfinite). |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. |
| * @example |
| * |
| * _.isFinite(10); |
| * // => true |
| * |
| * _.isFinite('10'); |
| * // => false |
| * |
| * _.isFinite(true); |
| * // => false |
| * |
| * _.isFinite(Object(10)); |
| * // => false |
| * |
| * _.isFinite(Infinity); |
| * // => false |
| */ |
| function isFinite(value) { |
| return typeof value == 'number' && nativeIsFinite(value); |
| } |
| /** |
| * Checks if `value` is classified as a `Function` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isFunction(_); |
| * // => true |
| * |
| * _.isFunction(/abc/); |
| * // => false |
| */ |
| function isFunction(value) { |
| // The use of `Object#toString` avoids issues with the `typeof` operator |
| // in older versions of Chrome and Safari which return 'function' for regexes |
| // and Safari 8 which returns 'object' for typed array constructors. |
| return isObject(value) && objToString.call(value) == funcTag; |
| } |
| /** |
| * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. |
| * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an object, else `false`. |
| * @example |
| * |
| * _.isObject({}); |
| * // => true |
| * |
| * _.isObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isObject(1); |
| * // => false |
| */ |
| function isObject(value) { |
| // Avoid a V8 JIT bug in Chrome 19-20. |
| // See https://code.google.com/p/v8/issues/detail?id=2291 for more details. |
| var type = typeof value; |
| return !!value && (type == 'object' || type == 'function'); |
| } |
| /** |
| * Performs a deep comparison between `object` and `source` to determine if |
| * `object` contains equivalent property values. If `customizer` is provided |
| * it's invoked to compare values. If `customizer` returns `undefined` |
| * comparisons are handled by the method instead. The `customizer` is bound |
| * to `thisArg` and invoked with three arguments: (value, other, index|key). |
| * |
| * **Note:** This method supports comparing properties of arrays, booleans, |
| * `Date` objects, numbers, `Object` objects, regexes, and strings. Functions |
| * and DOM nodes are **not** supported. Provide a customizer function to extend |
| * support for comparing other values. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {Object} object The object to inspect. |
| * @param {Object} source The object of property values to match. |
| * @param {Function} [customizer] The function to customize value comparisons. |
| * @param {*} [thisArg] The `this` binding of `customizer`. |
| * @returns {boolean} Returns `true` if `object` is a match, else `false`. |
| * @example |
| * |
| * var object = { 'user': 'fred', 'age': 40 }; |
| * |
| * _.isMatch(object, { 'age': 40 }); |
| * // => true |
| * |
| * _.isMatch(object, { 'age': 36 }); |
| * // => false |
| * |
| * // using a customizer callback |
| * var object = { 'greeting': 'hello' }; |
| * var source = { 'greeting': 'hi' }; |
| * |
| * _.isMatch(object, source, function(value, other) { |
| * return _.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/) || undefined; |
| * }); |
| * // => true |
| */ |
| function isMatch(object, source, customizer, thisArg) { |
| customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined; |
| return baseIsMatch(object, getMatchData(source), customizer); |
| } |
| /** |
| * Checks if `value` is `NaN`. |
| * |
| * **Note:** This method is not the same as [`isNaN`](https://es5.github.io/#x15.1.2.4) |
| * which returns `true` for `undefined` and other non-numeric values. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. |
| * @example |
| * |
| * _.isNaN(NaN); |
| * // => true |
| * |
| * _.isNaN(new Number(NaN)); |
| * // => true |
| * |
| * isNaN(undefined); |
| * // => true |
| * |
| * _.isNaN(undefined); |
| * // => false |
| */ |
| function isNaN(value) { |
| // An `NaN` primitive is the only value that is not equal to itself. |
| // Perform the `toStringTag` check first to avoid errors with some host objects in IE. |
| return isNumber(value) && value != +value; |
| } |
| /** |
| * Checks if `value` is a native function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a native function, else `false`. |
| * @example |
| * |
| * _.isNative(Array.prototype.push); |
| * // => true |
| * |
| * _.isNative(_); |
| * // => false |
| */ |
| function isNative(value) { |
| if (value == null) { |
| return false; |
| } |
| if (isFunction(value)) { |
| return reIsNative.test(fnToString.call(value)); |
| } |
| return isObjectLike(value) && reIsHostCtor.test(value); |
| } |
| /** |
| * Checks if `value` is `null`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is `null`, else `false`. |
| * @example |
| * |
| * _.isNull(null); |
| * // => true |
| * |
| * _.isNull(void 0); |
| * // => false |
| */ |
| function isNull(value) { |
| return value === null; |
| } |
| /** |
| * Checks if `value` is classified as a `Number` primitive or object. |
| * |
| * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified |
| * as numbers, use the `_.isFinite` method. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isNumber(8.4); |
| * // => true |
| * |
| * _.isNumber(NaN); |
| * // => true |
| * |
| * _.isNumber('8.4'); |
| * // => false |
| */ |
| function isNumber(value) { |
| return typeof value == 'number' || isObjectLike(value) && objToString.call(value) == numberTag; |
| } |
| /** |
| * Checks if `value` is a plain object, that is, an object created by the |
| * `Object` constructor or one with a `[[Prototype]]` of `null`. |
| * |
| * **Note:** This method assumes objects created by the `Object` constructor |
| * have no inherited enumerable properties. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * } |
| * |
| * _.isPlainObject(new Foo); |
| * // => false |
| * |
| * _.isPlainObject([1, 2, 3]); |
| * // => false |
| * |
| * _.isPlainObject({ 'x': 0, 'y': 0 }); |
| * // => true |
| * |
| * _.isPlainObject(Object.create(null)); |
| * // => true |
| */ |
| function isPlainObject(value) { |
| var Ctor; |
| // Exit early for non `Object` objects. |
| if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isArguments(value)) || !hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor))) { |
| return false; |
| } |
| // IE < 9 iterates inherited properties before own properties. If the first |
| // iterated property is an object's own property then there are no inherited |
| // enumerable properties. |
| var result; |
| // In most environments an object's own properties are iterated before |
| // its inherited properties. If the last iterated property is an object's |
| // own property then there are no inherited enumerable properties. |
| baseForIn(value, function (subValue, key) { |
| result = key; |
| }); |
| return result === undefined || hasOwnProperty.call(value, result); |
| } |
| /** |
| * Checks if `value` is classified as a `RegExp` object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isRegExp(/abc/); |
| * // => true |
| * |
| * _.isRegExp('/abc/'); |
| * // => false |
| */ |
| function isRegExp(value) { |
| return isObject(value) && objToString.call(value) == regexpTag; |
| } |
| /** |
| * Checks if `value` is classified as a `String` primitive or object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isString('abc'); |
| * // => true |
| * |
| * _.isString(1); |
| * // => false |
| */ |
| function isString(value) { |
| return typeof value == 'string' || isObjectLike(value) && objToString.call(value) == stringTag; |
| } |
| /** |
| * Checks if `value` is classified as a typed array. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. |
| * @example |
| * |
| * _.isTypedArray(new Uint8Array); |
| * // => true |
| * |
| * _.isTypedArray([]); |
| * // => false |
| */ |
| function isTypedArray(value) { |
| return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)]; |
| } |
| /** |
| * Checks if `value` is `undefined`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. |
| * @example |
| * |
| * _.isUndefined(void 0); |
| * // => true |
| * |
| * _.isUndefined(null); |
| * // => false |
| */ |
| function isUndefined(value) { |
| return value === undefined; |
| } |
| /** |
| * Checks if `value` is less than `other`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if `value` is less than `other`, else `false`. |
| * @example |
| * |
| * _.lt(1, 3); |
| * // => true |
| * |
| * _.lt(3, 3); |
| * // => false |
| * |
| * _.lt(3, 1); |
| * // => false |
| */ |
| function lt(value, other) { |
| return value < other; |
| } |
| /** |
| * Checks if `value` is less than or equal to `other`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to compare. |
| * @param {*} other The other value to compare. |
| * @returns {boolean} Returns `true` if `value` is less than or equal to `other`, else `false`. |
| * @example |
| * |
| * _.lte(1, 3); |
| * // => true |
| * |
| * _.lte(3, 3); |
| * // => true |
| * |
| * _.lte(3, 1); |
| * // => false |
| */ |
| function lte(value, other) { |
| return value <= other; |
| } |
| /** |
| * Converts `value` to an array. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to convert. |
| * @returns {Array} Returns the converted array. |
| * @example |
| * |
| * (function() { |
| * return _.toArray(arguments).slice(1); |
| * }(1, 2, 3)); |
| * // => [2, 3] |
| */ |
| function toArray(value) { |
| var length = value ? getLength(value) : 0; |
| if (!isLength(length)) { |
| return values(value); |
| } |
| if (!length) { |
| return []; |
| } |
| return arrayCopy(value); |
| } |
| /** |
| * Converts `value` to a plain object flattening inherited enumerable |
| * properties of `value` to own properties of the plain object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Lang |
| * @param {*} value The value to convert. |
| * @returns {Object} Returns the converted plain object. |
| * @example |
| * |
| * function Foo() { |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.assign({ 'a': 1 }, new Foo); |
| * // => { 'a': 1, 'b': 2 } |
| * |
| * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); |
| * // => { 'a': 1, 'b': 2, 'c': 3 } |
| */ |
| function toPlainObject(value) { |
| return baseCopy(value, keysIn(value)); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Recursively merges own enumerable properties of the source object(s), that |
| * don't resolve to `undefined` into the destination object. Subsequent sources |
| * overwrite property assignments of previous sources. If `customizer` is |
| * provided it's invoked to produce the merged values of the destination and |
| * source properties. If `customizer` returns `undefined` merging is handled |
| * by the method instead. The `customizer` is bound to `thisArg` and invoked |
| * with five arguments: (objectValue, sourceValue, key, object, source). |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @param {Function} [customizer] The function to customize assigned values. |
| * @param {*} [thisArg] The `this` binding of `customizer`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * var users = { |
| * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }] |
| * }; |
| * |
| * var ages = { |
| * 'data': [{ 'age': 36 }, { 'age': 40 }] |
| * }; |
| * |
| * _.merge(users, ages); |
| * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] } |
| * |
| * // using a customizer callback |
| * var object = { |
| * 'fruits': ['apple'], |
| * 'vegetables': ['beet'] |
| * }; |
| * |
| * var other = { |
| * 'fruits': ['banana'], |
| * 'vegetables': ['carrot'] |
| * }; |
| * |
| * _.merge(object, other, function(a, b) { |
| * if (_.isArray(a)) { |
| * return a.concat(b); |
| * } |
| * }); |
| * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] } |
| */ |
| var merge = createAssigner(baseMerge); |
| /** |
| * Assigns own enumerable properties of source object(s) to the destination |
| * object. Subsequent sources overwrite property assignments of previous sources. |
| * If `customizer` is provided it's invoked to produce the assigned values. |
| * The `customizer` is bound to `thisArg` and invoked with five arguments: |
| * (objectValue, sourceValue, key, object, source). |
| * |
| * **Note:** This method mutates `object` and is based on |
| * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign). |
| * |
| * @static |
| * @memberOf _ |
| * @alias extend |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @param {Function} [customizer] The function to customize assigned values. |
| * @param {*} [thisArg] The `this` binding of `customizer`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' }); |
| * // => { 'user': 'fred', 'age': 40 } |
| * |
| * // using a customizer callback |
| * var defaults = _.partialRight(_.assign, function(value, other) { |
| * return _.isUndefined(value) ? other : value; |
| * }); |
| * |
| * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' }); |
| * // => { 'user': 'barney', 'age': 36 } |
| */ |
| var assign = createAssigner(function (object, source, customizer) { |
| return customizer ? assignWith(object, source, customizer) : baseAssign(object, source); |
| }); |
| /** |
| * Creates an object that inherits from the given `prototype` object. If a |
| * `properties` object is provided its own enumerable properties are assigned |
| * to the created object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} prototype The object to inherit from. |
| * @param {Object} [properties] The properties to assign to the object. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * function Shape() { |
| * this.x = 0; |
| * this.y = 0; |
| * } |
| * |
| * function Circle() { |
| * Shape.call(this); |
| * } |
| * |
| * Circle.prototype = _.create(Shape.prototype, { |
| * 'constructor': Circle |
| * }); |
| * |
| * var circle = new Circle; |
| * circle instanceof Circle; |
| * // => true |
| * |
| * circle instanceof Shape; |
| * // => true |
| */ |
| function create(prototype, properties, guard) { |
| var result = baseCreate(prototype); |
| if (guard && isIterateeCall(prototype, properties, guard)) { |
| properties = undefined; |
| } |
| return properties ? baseAssign(result, properties) : result; |
| } |
| /** |
| * Assigns own enumerable properties of source object(s) to the destination |
| * object for all destination properties that resolve to `undefined`. Once a |
| * property is set, additional values of the same property are ignored. |
| * |
| * **Note:** This method mutates `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' }); |
| * // => { 'user': 'barney', 'age': 36 } |
| */ |
| var defaults = createDefaults(assign, assignDefaults); |
| /** |
| * This method is like `_.defaults` except that it recursively assigns |
| * default properties. |
| * |
| * **Note:** This method mutates `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The destination object. |
| * @param {...Object} [sources] The source objects. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * _.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } }); |
| * // => { 'user': { 'name': 'barney', 'age': 36 } } |
| * |
| */ |
| var defaultsDeep = createDefaults(merge, mergeDefaults); |
| /** |
| * This method is like `_.find` except that it returns the key of the first |
| * element `predicate` returns truthy for instead of the element itself. |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to search. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {string|undefined} Returns the key of the matched element, else `undefined`. |
| * @example |
| * |
| * var users = { |
| * 'barney': { 'age': 36, 'active': true }, |
| * 'fred': { 'age': 40, 'active': false }, |
| * 'pebbles': { 'age': 1, 'active': true } |
| * }; |
| * |
| * _.findKey(users, function(chr) { |
| * return chr.age < 40; |
| * }); |
| * // => 'barney' (iteration order is not guaranteed) |
| * |
| * // using the `_.matches` callback shorthand |
| * _.findKey(users, { 'age': 1, 'active': true }); |
| * // => 'pebbles' |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.findKey(users, 'active', false); |
| * // => 'fred' |
| * |
| * // using the `_.property` callback shorthand |
| * _.findKey(users, 'active'); |
| * // => 'barney' |
| */ |
| var findKey = createFindKey(baseForOwn); |
| /** |
| * This method is like `_.findKey` except that it iterates over elements of |
| * a collection in the opposite order. |
| * |
| * If a property name is provided for `predicate` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `predicate` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to search. |
| * @param {Function|Object|string} [predicate=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {string|undefined} Returns the key of the matched element, else `undefined`. |
| * @example |
| * |
| * var users = { |
| * 'barney': { 'age': 36, 'active': true }, |
| * 'fred': { 'age': 40, 'active': false }, |
| * 'pebbles': { 'age': 1, 'active': true } |
| * }; |
| * |
| * _.findLastKey(users, function(chr) { |
| * return chr.age < 40; |
| * }); |
| * // => returns `pebbles` assuming `_.findKey` returns `barney` |
| * |
| * // using the `_.matches` callback shorthand |
| * _.findLastKey(users, { 'age': 36, 'active': true }); |
| * // => 'barney' |
| * |
| * // using the `_.matchesProperty` callback shorthand |
| * _.findLastKey(users, 'active', false); |
| * // => 'fred' |
| * |
| * // using the `_.property` callback shorthand |
| * _.findLastKey(users, 'active'); |
| * // => 'pebbles' |
| */ |
| var findLastKey = createFindKey(baseForOwnRight); |
| /** |
| * Iterates over own and inherited enumerable properties of an object invoking |
| * `iteratee` for each property. The `iteratee` is bound to `thisArg` and invoked |
| * with three arguments: (value, key, object). Iteratee functions may exit |
| * iteration early by explicitly returning `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.forIn(new Foo, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'a', 'b', and 'c' (iteration order is not guaranteed) |
| */ |
| var forIn = createForIn(baseFor); |
| /** |
| * This method is like `_.forIn` except that it iterates over properties of |
| * `object` in the opposite order. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.forInRight(new Foo, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'c', 'b', and 'a' assuming `_.forIn ` logs 'a', 'b', and 'c' |
| */ |
| var forInRight = createForIn(baseForRight); |
| /** |
| * Iterates over own enumerable properties of an object invoking `iteratee` |
| * for each property. The `iteratee` is bound to `thisArg` and invoked with |
| * three arguments: (value, key, object). Iteratee functions may exit iteration |
| * early by explicitly returning `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.forOwn(new Foo, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'a' and 'b' (iteration order is not guaranteed) |
| */ |
| var forOwn = createForOwn(baseForOwn); |
| /** |
| * This method is like `_.forOwn` except that it iterates over properties of |
| * `object` in the opposite order. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.forOwnRight(new Foo, function(value, key) { |
| * console.log(key); |
| * }); |
| * // => logs 'b' and 'a' assuming `_.forOwn` logs 'a' and 'b' |
| */ |
| var forOwnRight = createForOwn(baseForOwnRight); |
| /** |
| * Creates an array of function property names from all enumerable properties, |
| * own and inherited, of `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias methods |
| * @category Object |
| * @param {Object} object The object to inspect. |
| * @returns {Array} Returns the new array of property names. |
| * @example |
| * |
| * _.functions(_); |
| * // => ['after', 'ary', 'assign', ...] |
| */ |
| function functions(object) { |
| return baseFunctions(object, keysIn(object)); |
| } |
| /** |
| * Gets the property value at `path` of `object`. If the resolved value is |
| * `undefined` the `defaultValue` is used in its place. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path of the property to get. |
| * @param {*} [defaultValue] The value returned if the resolved value is `undefined`. |
| * @returns {*} Returns the resolved value. |
| * @example |
| * |
| * var object = { 'a': [{ 'b': { 'c': 3 } }] }; |
| * |
| * _.get(object, 'a[0].b.c'); |
| * // => 3 |
| * |
| * _.get(object, ['a', '0', 'b', 'c']); |
| * // => 3 |
| * |
| * _.get(object, 'a.b.c', 'default'); |
| * // => 'default' |
| */ |
| function get(object, path, defaultValue) { |
| var result = object == null ? undefined : baseGet(object, toPath(path), path + ''); |
| return result === undefined ? defaultValue : result; |
| } |
| /** |
| * Checks if `path` is a direct property. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path to check. |
| * @returns {boolean} Returns `true` if `path` is a direct property, else `false`. |
| * @example |
| * |
| * var object = { 'a': { 'b': { 'c': 3 } } }; |
| * |
| * _.has(object, 'a'); |
| * // => true |
| * |
| * _.has(object, 'a.b.c'); |
| * // => true |
| * |
| * _.has(object, ['a', 'b', 'c']); |
| * // => true |
| */ |
| function has(object, path) { |
| if (object == null) { |
| return false; |
| } |
| var result = hasOwnProperty.call(object, path); |
| if (!result && !isKey(path)) { |
| path = toPath(path); |
| object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1)); |
| if (object == null) { |
| return false; |
| } |
| path = last(path); |
| result = hasOwnProperty.call(object, path); |
| } |
| return result || isLength(object.length) && isIndex(path, object.length) && (isArray(object) || isArguments(object)); |
| } |
| /** |
| * Creates an object composed of the inverted keys and values of `object`. |
| * If `object` contains duplicate values, subsequent values overwrite property |
| * assignments of previous values unless `multiValue` is `true`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to invert. |
| * @param {boolean} [multiValue] Allow multiple values per key. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Object} Returns the new inverted object. |
| * @example |
| * |
| * var object = { 'a': 1, 'b': 2, 'c': 1 }; |
| * |
| * _.invert(object); |
| * // => { '1': 'c', '2': 'b' } |
| * |
| * // with `multiValue` |
| * _.invert(object, true); |
| * // => { '1': ['a', 'c'], '2': ['b'] } |
| */ |
| function invert(object, multiValue, guard) { |
| if (guard && isIterateeCall(object, multiValue, guard)) { |
| multiValue = undefined; |
| } |
| var index = -1, props = keys(object), length = props.length, result = {}; |
| while (++index < length) { |
| var key = props[index], value = object[key]; |
| if (multiValue) { |
| if (hasOwnProperty.call(result, value)) { |
| result[value].push(key); |
| } else { |
| result[value] = [key]; |
| } |
| } else { |
| result[value] = key; |
| } |
| } |
| return result; |
| } |
| /** |
| * Creates an array of the own enumerable property names of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. See the |
| * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) |
| * for more details. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.keys(new Foo); |
| * // => ['a', 'b'] (iteration order is not guaranteed) |
| * |
| * _.keys('hi'); |
| * // => ['0', '1'] |
| */ |
| var keys = !nativeKeys ? shimKeys : function (object) { |
| var Ctor = object == null ? undefined : object.constructor; |
| if (typeof Ctor == 'function' && Ctor.prototype === object || typeof object != 'function' && isArrayLike(object)) { |
| return shimKeys(object); |
| } |
| return isObject(object) ? nativeKeys(object) : []; |
| }; |
| /** |
| * Creates an array of the own and inherited enumerable property names of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property names. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.keysIn(new Foo); |
| * // => ['a', 'b', 'c'] (iteration order is not guaranteed) |
| */ |
| function keysIn(object) { |
| if (object == null) { |
| return []; |
| } |
| if (!isObject(object)) { |
| object = Object(object); |
| } |
| var length = object.length; |
| length = length && isLength(length) && (isArray(object) || isArguments(object)) && length || 0; |
| var Ctor = object.constructor, index = -1, isProto = typeof Ctor == 'function' && Ctor.prototype === object, result = Array(length), skipIndexes = length > 0; |
| while (++index < length) { |
| result[index] = index + ''; |
| } |
| for (var key in object) { |
| if (!(skipIndexes && isIndex(key, length)) && !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { |
| result.push(key); |
| } |
| } |
| return result; |
| } |
| /** |
| * The opposite of `_.mapValues`; this method creates an object with the |
| * same values as `object` and keys generated by running each own enumerable |
| * property of `object` through `iteratee`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns the new mapped object. |
| * @example |
| * |
| * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { |
| * return key + value; |
| * }); |
| * // => { 'a1': 1, 'b2': 2 } |
| */ |
| var mapKeys = createObjectMapper(true); |
| /** |
| * Creates an object with the same keys as `object` and values generated by |
| * running each own enumerable property of `object` through `iteratee`. The |
| * iteratee function is bound to `thisArg` and invoked with three arguments: |
| * (value, key, object). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to iterate over. |
| * @param {Function|Object|string} [iteratee=_.identity] The function invoked |
| * per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Object} Returns the new mapped object. |
| * @example |
| * |
| * _.mapValues({ 'a': 1, 'b': 2 }, function(n) { |
| * return n * 3; |
| * }); |
| * // => { 'a': 3, 'b': 6 } |
| * |
| * var users = { |
| * 'fred': { 'user': 'fred', 'age': 40 }, |
| * 'pebbles': { 'user': 'pebbles', 'age': 1 } |
| * }; |
| * |
| * // using the `_.property` callback shorthand |
| * _.mapValues(users, 'age'); |
| * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) |
| */ |
| var mapValues = createObjectMapper(); |
| /** |
| * The opposite of `_.pick`; this method creates an object composed of the |
| * own and inherited enumerable properties of `object` that are not omitted. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The source object. |
| * @param {Function|...(string|string[])} [predicate] The function invoked per |
| * iteration or property names to omit, specified as individual property |
| * names or arrays of property names. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * var object = { 'user': 'fred', 'age': 40 }; |
| * |
| * _.omit(object, 'age'); |
| * // => { 'user': 'fred' } |
| * |
| * _.omit(object, _.isNumber); |
| * // => { 'user': 'fred' } |
| */ |
| var omit = restParam(function (object, props) { |
| if (object == null) { |
| return {}; |
| } |
| if (typeof props[0] != 'function') { |
| var props = arrayMap(baseFlatten(props), String); |
| return pickByArray(object, baseDifference(keysIn(object), props)); |
| } |
| var predicate = bindCallback(props[0], props[1], 3); |
| return pickByCallback(object, function (value, key, object) { |
| return !predicate(value, key, object); |
| }); |
| }); |
| /** |
| * Creates a two dimensional array of the key-value pairs for `object`, |
| * e.g. `[[key1, value1], [key2, value2]]`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the new array of key-value pairs. |
| * @example |
| * |
| * _.pairs({ 'barney': 36, 'fred': 40 }); |
| * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed) |
| */ |
| function pairs(object) { |
| object = toObject(object); |
| var index = -1, props = keys(object), length = props.length, result = Array(length); |
| while (++index < length) { |
| var key = props[index]; |
| result[index] = [ |
| key, |
| object[key] |
| ]; |
| } |
| return result; |
| } |
| /** |
| * Creates an object composed of the picked `object` properties. Property |
| * names may be specified as individual arguments or as arrays of property |
| * names. If `predicate` is provided it's invoked for each property of `object` |
| * picking the properties `predicate` returns truthy for. The predicate is |
| * bound to `thisArg` and invoked with three arguments: (value, key, object). |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The source object. |
| * @param {Function|...(string|string[])} [predicate] The function invoked per |
| * iteration or property names to pick, specified as individual property |
| * names or arrays of property names. |
| * @param {*} [thisArg] The `this` binding of `predicate`. |
| * @returns {Object} Returns the new object. |
| * @example |
| * |
| * var object = { 'user': 'fred', 'age': 40 }; |
| * |
| * _.pick(object, 'user'); |
| * // => { 'user': 'fred' } |
| * |
| * _.pick(object, _.isString); |
| * // => { 'user': 'fred' } |
| */ |
| var pick = restParam(function (object, props) { |
| if (object == null) { |
| return {}; |
| } |
| return typeof props[0] == 'function' ? pickByCallback(object, bindCallback(props[0], props[1], 3)) : pickByArray(object, baseFlatten(props)); |
| }); |
| /** |
| * This method is like `_.get` except that if the resolved value is a function |
| * it's invoked with the `this` binding of its parent object and its result |
| * is returned. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @param {Array|string} path The path of the property to resolve. |
| * @param {*} [defaultValue] The value returned if the resolved value is `undefined`. |
| * @returns {*} Returns the resolved value. |
| * @example |
| * |
| * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; |
| * |
| * _.result(object, 'a[0].b.c1'); |
| * // => 3 |
| * |
| * _.result(object, 'a[0].b.c2'); |
| * // => 4 |
| * |
| * _.result(object, 'a.b.c', 'default'); |
| * // => 'default' |
| * |
| * _.result(object, 'a.b.c', _.constant('default')); |
| * // => 'default' |
| */ |
| function result(object, path, defaultValue) { |
| var result = object == null ? undefined : object[path]; |
| if (result === undefined) { |
| if (object != null && !isKey(path, object)) { |
| path = toPath(path); |
| object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1)); |
| result = object == null ? undefined : object[last(path)]; |
| } |
| result = result === undefined ? defaultValue : result; |
| } |
| return isFunction(result) ? result.call(object) : result; |
| } |
| /** |
| * Sets the property value of `path` on `object`. If a portion of `path` |
| * does not exist it's created. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to augment. |
| * @param {Array|string} path The path of the property to set. |
| * @param {*} value The value to set. |
| * @returns {Object} Returns `object`. |
| * @example |
| * |
| * var object = { 'a': [{ 'b': { 'c': 3 } }] }; |
| * |
| * _.set(object, 'a[0].b.c', 4); |
| * console.log(object.a[0].b.c); |
| * // => 4 |
| * |
| * _.set(object, 'x[0].y.z', 5); |
| * console.log(object.x[0].y.z); |
| * // => 5 |
| */ |
| function set(object, path, value) { |
| if (object == null) { |
| return object; |
| } |
| var pathKey = path + ''; |
| path = object[pathKey] != null || isKey(path, object) ? [pathKey] : toPath(path); |
| var index = -1, length = path.length, lastIndex = length - 1, nested = object; |
| while (nested != null && ++index < length) { |
| var key = path[index]; |
| if (isObject(nested)) { |
| if (index == lastIndex) { |
| nested[key] = value; |
| } else if (nested[key] == null) { |
| nested[key] = isIndex(path[index + 1]) ? [] : {}; |
| } |
| } |
| nested = nested[key]; |
| } |
| return object; |
| } |
| /** |
| * An alternative to `_.reduce`; this method transforms `object` to a new |
| * `accumulator` object which is the result of running each of its own enumerable |
| * properties through `iteratee`, with each invocation potentially mutating |
| * the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked |
| * with four arguments: (accumulator, value, key, object). Iteratee functions |
| * may exit iteration early by explicitly returning `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Array|Object} object The object to iterate over. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [accumulator] The custom accumulator value. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {*} Returns the accumulated value. |
| * @example |
| * |
| * _.transform([2, 3, 4], function(result, n) { |
| * result.push(n *= n); |
| * return n % 2 == 0; |
| * }); |
| * // => [4, 9] |
| * |
| * _.transform({ 'a': 1, 'b': 2 }, function(result, n, key) { |
| * result[key] = n * 3; |
| * }); |
| * // => { 'a': 3, 'b': 6 } |
| */ |
| function transform(object, iteratee, accumulator, thisArg) { |
| var isArr = isArray(object) || isTypedArray(object); |
| iteratee = getCallback(iteratee, thisArg, 4); |
| if (accumulator == null) { |
| if (isArr || isObject(object)) { |
| var Ctor = object.constructor; |
| if (isArr) { |
| accumulator = isArray(object) ? new Ctor() : []; |
| } else { |
| accumulator = baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined); |
| } |
| } else { |
| accumulator = {}; |
| } |
| } |
| (isArr ? arrayEach : baseForOwn)(object, function (value, index, object) { |
| return iteratee(accumulator, value, index, object); |
| }); |
| return accumulator; |
| } |
| /** |
| * Creates an array of the own enumerable property values of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property values. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.values(new Foo); |
| * // => [1, 2] (iteration order is not guaranteed) |
| * |
| * _.values('hi'); |
| * // => ['h', 'i'] |
| */ |
| function values(object) { |
| return baseValues(object, keys(object)); |
| } |
| /** |
| * Creates an array of the own and inherited enumerable property values |
| * of `object`. |
| * |
| * **Note:** Non-object values are coerced to objects. |
| * |
| * @static |
| * @memberOf _ |
| * @category Object |
| * @param {Object} object The object to query. |
| * @returns {Array} Returns the array of property values. |
| * @example |
| * |
| * function Foo() { |
| * this.a = 1; |
| * this.b = 2; |
| * } |
| * |
| * Foo.prototype.c = 3; |
| * |
| * _.valuesIn(new Foo); |
| * // => [1, 2, 3] (iteration order is not guaranteed) |
| */ |
| function valuesIn(object) { |
| return baseValues(object, keysIn(object)); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Checks if `n` is between `start` and up to but not including, `end`. If |
| * `end` is not specified it's set to `start` with `start` then set to `0`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Number |
| * @param {number} n The number to check. |
| * @param {number} [start=0] The start of the range. |
| * @param {number} end The end of the range. |
| * @returns {boolean} Returns `true` if `n` is in the range, else `false`. |
| * @example |
| * |
| * _.inRange(3, 2, 4); |
| * // => true |
| * |
| * _.inRange(4, 8); |
| * // => true |
| * |
| * _.inRange(4, 2); |
| * // => false |
| * |
| * _.inRange(2, 2); |
| * // => false |
| * |
| * _.inRange(1.2, 2); |
| * // => true |
| * |
| * _.inRange(5.2, 4); |
| * // => false |
| */ |
| function inRange(value, start, end) { |
| start = +start || 0; |
| if (end === undefined) { |
| end = start; |
| start = 0; |
| } else { |
| end = +end || 0; |
| } |
| return value >= nativeMin(start, end) && value < nativeMax(start, end); |
| } |
| /** |
| * Produces a random number between `min` and `max` (inclusive). If only one |
| * argument is provided a number between `0` and the given number is returned. |
| * If `floating` is `true`, or either `min` or `max` are floats, a floating-point |
| * number is returned instead of an integer. |
| * |
| * @static |
| * @memberOf _ |
| * @category Number |
| * @param {number} [min=0] The minimum possible value. |
| * @param {number} [max=1] The maximum possible value. |
| * @param {boolean} [floating] Specify returning a floating-point number. |
| * @returns {number} Returns the random number. |
| * @example |
| * |
| * _.random(0, 5); |
| * // => an integer between 0 and 5 |
| * |
| * _.random(5); |
| * // => also an integer between 0 and 5 |
| * |
| * _.random(5, true); |
| * // => a floating-point number between 0 and 5 |
| * |
| * _.random(1.2, 5.2); |
| * // => a floating-point number between 1.2 and 5.2 |
| */ |
| function random(min, max, floating) { |
| if (floating && isIterateeCall(min, max, floating)) { |
| max = floating = undefined; |
| } |
| var noMin = min == null, noMax = max == null; |
| if (floating == null) { |
| if (noMax && typeof min == 'boolean') { |
| floating = min; |
| min = 1; |
| } else if (typeof max == 'boolean') { |
| floating = max; |
| noMax = true; |
| } |
| } |
| if (noMin && noMax) { |
| max = 1; |
| noMax = false; |
| } |
| min = +min || 0; |
| if (noMax) { |
| max = min; |
| min = 0; |
| } else { |
| max = +max || 0; |
| } |
| if (floating || min % 1 || max % 1) { |
| var rand = nativeRandom(); |
| return nativeMin(min + rand * (max - min + parseFloat('1e-' + ((rand + '').length - 1))), max); |
| } |
| return baseRandom(min, max); |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to convert. |
| * @returns {string} Returns the camel cased string. |
| * @example |
| * |
| * _.camelCase('Foo Bar'); |
| * // => 'fooBar' |
| * |
| * _.camelCase('--foo-bar'); |
| * // => 'fooBar' |
| * |
| * _.camelCase('__foo_bar__'); |
| * // => 'fooBar' |
| */ |
| var camelCase = createCompounder(function (result, word, index) { |
| word = word.toLowerCase(); |
| return result + (index ? word.charAt(0).toUpperCase() + word.slice(1) : word); |
| }); |
| /** |
| * Capitalizes the first character of `string`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to capitalize. |
| * @returns {string} Returns the capitalized string. |
| * @example |
| * |
| * _.capitalize('fred'); |
| * // => 'Fred' |
| */ |
| function capitalize(string) { |
| string = baseToString(string); |
| return string && string.charAt(0).toUpperCase() + string.slice(1); |
| } |
| /** |
| * Deburrs `string` by converting [latin-1 supplementary letters](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) |
| * to basic latin letters and removing [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to deburr. |
| * @returns {string} Returns the deburred string. |
| * @example |
| * |
| * _.deburr('déjà vu'); |
| * // => 'deja vu' |
| */ |
| function deburr(string) { |
| string = baseToString(string); |
| return string && string.replace(reLatin1, deburrLetter).replace(reComboMark, ''); |
| } |
| /** |
| * Checks if `string` ends with the given target string. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to search. |
| * @param {string} [target] The string to search for. |
| * @param {number} [position=string.length] The position to search from. |
| * @returns {boolean} Returns `true` if `string` ends with `target`, else `false`. |
| * @example |
| * |
| * _.endsWith('abc', 'c'); |
| * // => true |
| * |
| * _.endsWith('abc', 'b'); |
| * // => false |
| * |
| * _.endsWith('abc', 'b', 2); |
| * // => true |
| */ |
| function endsWith(string, target, position) { |
| string = baseToString(string); |
| target = target + ''; |
| var length = string.length; |
| position = position === undefined ? length : nativeMin(position < 0 ? 0 : +position || 0, length); |
| position -= target.length; |
| return position >= 0 && string.indexOf(target, position) == position; |
| } |
| /** |
| * Converts the characters "&", "<", ">", '"', "'", and "\`", in `string` to |
| * their corresponding HTML entities. |
| * |
| * **Note:** No other characters are escaped. To escape additional characters |
| * use a third-party library like [_he_](https://mths.be/he). |
| * |
| * Though the ">" character is escaped for symmetry, characters like |
| * ">" and "/" don't need escaping in HTML and have no special meaning |
| * unless they're part of a tag or unquoted attribute value. |
| * See [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) |
| * (under "semi-related fun fact") for more details. |
| * |
| * Backticks are escaped because in Internet Explorer < 9, they can break out |
| * of attribute values or HTML comments. See [#59](https://html5sec.org/#59), |
| * [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and |
| * [#133](https://html5sec.org/#133) of the [HTML5 Security Cheatsheet](https://html5sec.org/) |
| * for more details. |
| * |
| * When working with HTML you should always [quote attribute values](http://wonko.com/post/html-escaping) |
| * to reduce XSS vectors. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to escape. |
| * @returns {string} Returns the escaped string. |
| * @example |
| * |
| * _.escape('fred, barney, & pebbles'); |
| * // => 'fred, barney, & pebbles' |
| */ |
| function escape(string) { |
| // Reset `lastIndex` because in IE < 9 `String#replace` does not. |
| string = baseToString(string); |
| return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string; |
| } |
| /** |
| * Escapes the `RegExp` special characters "\", "/", "^", "$", ".", "|", "?", |
| * "*", "+", "(", ")", "[", "]", "{" and "}" in `string`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to escape. |
| * @returns {string} Returns the escaped string. |
| * @example |
| * |
| * _.escapeRegExp('[lodash](https://lodash.com/)'); |
| * // => '\[lodash\]\(https:\/\/lodash\.com\/\)' |
| */ |
| function escapeRegExp(string) { |
| string = baseToString(string); |
| return string && reHasRegExpChars.test(string) ? string.replace(reRegExpChars, escapeRegExpChar) : string || '(?:)'; |
| } |
| /** |
| * Converts `string` to [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to convert. |
| * @returns {string} Returns the kebab cased string. |
| * @example |
| * |
| * _.kebabCase('Foo Bar'); |
| * // => 'foo-bar' |
| * |
| * _.kebabCase('fooBar'); |
| * // => 'foo-bar' |
| * |
| * _.kebabCase('__foo_bar__'); |
| * // => 'foo-bar' |
| */ |
| var kebabCase = createCompounder(function (result, word, index) { |
| return result + (index ? '-' : '') + word.toLowerCase(); |
| }); |
| /** |
| * Pads `string` on the left and right sides if it's shorter than `length`. |
| * Padding characters are truncated if they can't be evenly divided by `length`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to pad. |
| * @param {number} [length=0] The padding length. |
| * @param {string} [chars=' '] The string used as padding. |
| * @returns {string} Returns the padded string. |
| * @example |
| * |
| * _.pad('abc', 8); |
| * // => ' abc ' |
| * |
| * _.pad('abc', 8, '_-'); |
| * // => '_-abc_-_' |
| * |
| * _.pad('abc', 3); |
| * // => 'abc' |
| */ |
| function pad(string, length, chars) { |
| string = baseToString(string); |
| length = +length; |
| var strLength = string.length; |
| if (strLength >= length || !nativeIsFinite(length)) { |
| return string; |
| } |
| var mid = (length - strLength) / 2, leftLength = nativeFloor(mid), rightLength = nativeCeil(mid); |
| chars = createPadding('', rightLength, chars); |
| return chars.slice(0, leftLength) + string + chars; |
| } |
| /** |
| * Pads `string` on the left side if it's shorter than `length`. Padding |
| * characters are truncated if they exceed `length`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to pad. |
| * @param {number} [length=0] The padding length. |
| * @param {string} [chars=' '] The string used as padding. |
| * @returns {string} Returns the padded string. |
| * @example |
| * |
| * _.padLeft('abc', 6); |
| * // => ' abc' |
| * |
| * _.padLeft('abc', 6, '_-'); |
| * // => '_-_abc' |
| * |
| * _.padLeft('abc', 3); |
| * // => 'abc' |
| */ |
| var padLeft = createPadDir(); |
| /** |
| * Pads `string` on the right side if it's shorter than `length`. Padding |
| * characters are truncated if they exceed `length`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to pad. |
| * @param {number} [length=0] The padding length. |
| * @param {string} [chars=' '] The string used as padding. |
| * @returns {string} Returns the padded string. |
| * @example |
| * |
| * _.padRight('abc', 6); |
| * // => 'abc ' |
| * |
| * _.padRight('abc', 6, '_-'); |
| * // => 'abc_-_' |
| * |
| * _.padRight('abc', 3); |
| * // => 'abc' |
| */ |
| var padRight = createPadDir(true); |
| /** |
| * Converts `string` to an integer of the specified radix. If `radix` is |
| * `undefined` or `0`, a `radix` of `10` is used unless `value` is a hexadecimal, |
| * in which case a `radix` of `16` is used. |
| * |
| * **Note:** This method aligns with the [ES5 implementation](https://es5.github.io/#E) |
| * of `parseInt`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} string The string to convert. |
| * @param {number} [radix] The radix to interpret `value` by. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {number} Returns the converted integer. |
| * @example |
| * |
| * _.parseInt('08'); |
| * // => 8 |
| * |
| * _.map(['6', '08', '10'], _.parseInt); |
| * // => [6, 8, 10] |
| */ |
| function parseInt(string, radix, guard) { |
| // Firefox < 21 and Opera < 15 follow ES3 for `parseInt`. |
| // Chrome fails to trim leading <BOM> whitespace characters. |
| // See https://code.google.com/p/v8/issues/detail?id=3109 for more details. |
| if (guard ? isIterateeCall(string, radix, guard) : radix == null) { |
| radix = 0; |
| } else if (radix) { |
| radix = +radix; |
| } |
| string = trim(string); |
| return nativeParseInt(string, radix || (reHasHexPrefix.test(string) ? 16 : 10)); |
| } |
| /** |
| * Repeats the given string `n` times. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to repeat. |
| * @param {number} [n=0] The number of times to repeat the string. |
| * @returns {string} Returns the repeated string. |
| * @example |
| * |
| * _.repeat('*', 3); |
| * // => '***' |
| * |
| * _.repeat('abc', 2); |
| * // => 'abcabc' |
| * |
| * _.repeat('abc', 0); |
| * // => '' |
| */ |
| function repeat(string, n) { |
| var result = ''; |
| string = baseToString(string); |
| n = +n; |
| if (n < 1 || !string || !nativeIsFinite(n)) { |
| return result; |
| } |
| // Leverage the exponentiation by squaring algorithm for a faster repeat. |
| // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. |
| do { |
| if (n % 2) { |
| result += string; |
| } |
| n = nativeFloor(n / 2); |
| string += string; |
| } while (n); |
| return result; |
| } |
| /** |
| * Converts `string` to [snake case](https://en.wikipedia.org/wiki/Snake_case). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to convert. |
| * @returns {string} Returns the snake cased string. |
| * @example |
| * |
| * _.snakeCase('Foo Bar'); |
| * // => 'foo_bar' |
| * |
| * _.snakeCase('fooBar'); |
| * // => 'foo_bar' |
| * |
| * _.snakeCase('--foo-bar'); |
| * // => 'foo_bar' |
| */ |
| var snakeCase = createCompounder(function (result, word, index) { |
| return result + (index ? '_' : '') + word.toLowerCase(); |
| }); |
| /** |
| * Converts `string` to [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to convert. |
| * @returns {string} Returns the start cased string. |
| * @example |
| * |
| * _.startCase('--foo-bar'); |
| * // => 'Foo Bar' |
| * |
| * _.startCase('fooBar'); |
| * // => 'Foo Bar' |
| * |
| * _.startCase('__foo_bar__'); |
| * // => 'Foo Bar' |
| */ |
| var startCase = createCompounder(function (result, word, index) { |
| return result + (index ? ' ' : '') + (word.charAt(0).toUpperCase() + word.slice(1)); |
| }); |
| /** |
| * Checks if `string` starts with the given target string. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to search. |
| * @param {string} [target] The string to search for. |
| * @param {number} [position=0] The position to search from. |
| * @returns {boolean} Returns `true` if `string` starts with `target`, else `false`. |
| * @example |
| * |
| * _.startsWith('abc', 'a'); |
| * // => true |
| * |
| * _.startsWith('abc', 'b'); |
| * // => false |
| * |
| * _.startsWith('abc', 'b', 1); |
| * // => true |
| */ |
| function startsWith(string, target, position) { |
| string = baseToString(string); |
| position = position == null ? 0 : nativeMin(position < 0 ? 0 : +position || 0, string.length); |
| return string.lastIndexOf(target, position) == position; |
| } |
| /** |
| * Creates a compiled template function that can interpolate data properties |
| * in "interpolate" delimiters, HTML-escape interpolated data properties in |
| * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data |
| * properties may be accessed as free variables in the template. If a setting |
| * object is provided it takes precedence over `_.templateSettings` values. |
| * |
| * **Note:** In the development build `_.template` utilizes |
| * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) |
| * for easier debugging. |
| * |
| * For more information on precompiling templates see |
| * [lodash's custom builds documentation](https://lodash.com/custom-builds). |
| * |
| * For more information on Chrome extension sandboxes see |
| * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The template string. |
| * @param {Object} [options] The options object. |
| * @param {RegExp} [options.escape] The HTML "escape" delimiter. |
| * @param {RegExp} [options.evaluate] The "evaluate" delimiter. |
| * @param {Object} [options.imports] An object to import into the template as free variables. |
| * @param {RegExp} [options.interpolate] The "interpolate" delimiter. |
| * @param {string} [options.sourceURL] The sourceURL of the template's compiled source. |
| * @param {string} [options.variable] The data object variable name. |
| * @param- {Object} [otherOptions] Enables the legacy `options` param signature. |
| * @returns {Function} Returns the compiled template function. |
| * @example |
| * |
| * // using the "interpolate" delimiter to create a compiled template |
| * var compiled = _.template('hello <%= user %>!'); |
| * compiled({ 'user': 'fred' }); |
| * // => 'hello fred!' |
| * |
| * // using the HTML "escape" delimiter to escape data property values |
| * var compiled = _.template('<b><%- value %></b>'); |
| * compiled({ 'value': '<script>' }); |
| * // => '<b><script></b>' |
| * |
| * // using the "evaluate" delimiter to execute JavaScript and generate HTML |
| * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>'); |
| * compiled({ 'users': ['fred', 'barney'] }); |
| * // => '<li>fred</li><li>barney</li>' |
| * |
| * // using the internal `print` function in "evaluate" delimiters |
| * var compiled = _.template('<% print("hello " + user); %>!'); |
| * compiled({ 'user': 'barney' }); |
| * // => 'hello barney!' |
| * |
| * // using the ES delimiter as an alternative to the default "interpolate" delimiter |
| * var compiled = _.template('hello ${ user }!'); |
| * compiled({ 'user': 'pebbles' }); |
| * // => 'hello pebbles!' |
| * |
| * // using custom template delimiters |
| * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g; |
| * var compiled = _.template('hello {{ user }}!'); |
| * compiled({ 'user': 'mustache' }); |
| * // => 'hello mustache!' |
| * |
| * // using backslashes to treat delimiters as plain text |
| * var compiled = _.template('<%= "\\<%- value %\\>" %>'); |
| * compiled({ 'value': 'ignored' }); |
| * // => '<%- value %>' |
| * |
| * // using the `imports` option to import `jQuery` as `jq` |
| * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>'; |
| * var compiled = _.template(text, { 'imports': { 'jq': jQuery } }); |
| * compiled({ 'users': ['fred', 'barney'] }); |
| * // => '<li>fred</li><li>barney</li>' |
| * |
| * // using the `sourceURL` option to specify a custom sourceURL for the template |
| * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' }); |
| * compiled(data); |
| * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector |
| * |
| * // using the `variable` option to ensure a with-statement isn't used in the compiled template |
| * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' }); |
| * compiled.source; |
| * // => function(data) { |
| * // var __t, __p = ''; |
| * // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!'; |
| * // return __p; |
| * // } |
| * |
| * // using the `source` property to inline compiled templates for meaningful |
| * // line numbers in error messages and a stack trace |
| * fs.writeFileSync(path.join(cwd, 'jst.js'), '\ |
| * var JST = {\ |
| * "main": ' + _.template(mainText).source + '\ |
| * };\ |
| * '); |
| */ |
| function template(string, options, otherOptions) { |
| // Based on John Resig's `tmpl` implementation (http://ejohn.org/blog/javascript-micro-templating/) |
| // and Laura Doktorova's doT.js (https://github.com/olado/doT). |
| var settings = lodash.templateSettings; |
| if (otherOptions && isIterateeCall(string, options, otherOptions)) { |
| options = otherOptions = undefined; |
| } |
| string = baseToString(string); |
| options = assignWith(baseAssign({}, otherOptions || options), settings, assignOwnDefaults); |
| var imports = assignWith(baseAssign({}, options.imports), settings.imports, assignOwnDefaults), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys); |
| var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = '__p += \''; |
| // Compile the regexp to match each delimiter. |
| var reDelimiters = RegExp((options.escape || reNoMatch).source + '|' + interpolate.source + '|' + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' + (options.evaluate || reNoMatch).source + '|$', 'g'); |
| // Use a sourceURL for easier debugging. |
| var sourceURL = '//# sourceURL=' + ('sourceURL' in options ? options.sourceURL : 'lodash.templateSources[' + ++templateCounter + ']') + '\n'; |
| string.replace(reDelimiters, function (match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) { |
| interpolateValue || (interpolateValue = esTemplateValue); |
| // Escape characters that can't be included in string literals. |
| source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar); |
| // Replace delimiters with snippets. |
| if (escapeValue) { |
| isEscaping = true; |
| source += '\' +\n__e(' + escapeValue + ') +\n\''; |
| } |
| if (evaluateValue) { |
| isEvaluating = true; |
| source += '\';\n' + evaluateValue + ';\n__p += \''; |
| } |
| if (interpolateValue) { |
| source += '\' +\n((__t = (' + interpolateValue + ')) == null ? \'\' : __t) +\n\''; |
| } |
| index = offset + match.length; |
| // The JS engine embedded in Adobe products requires returning the `match` |
| // string in order to produce the correct `offset` value. |
| return match; |
| }); |
| source += '\';\n'; |
| // If `variable` is not specified wrap a with-statement around the generated |
| // code to add the data object to the top of the scope chain. |
| var variable = options.variable; |
| if (!variable) { |
| source = 'with (obj) {\n' + source + '\n}\n'; |
| } |
| // Cleanup code by stripping empty strings. |
| source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source).replace(reEmptyStringMiddle, '$1').replace(reEmptyStringTrailing, '$1;'); |
| // Frame code as the function body. |
| source = 'function(' + (variable || 'obj') + ') {\n' + (variable ? '' : 'obj || (obj = {});\n') + 'var __t, __p = \'\'' + (isEscaping ? ', __e = _.escape' : '') + (isEvaluating ? ', __j = Array.prototype.join;\n' + 'function print() { __p += __j.call(arguments, \'\') }\n' : ';\n') + source + 'return __p\n}'; |
| var result = attempt(function () { |
| return Function(importsKeys, sourceURL + 'return ' + source).apply(undefined, importsValues); |
| }); |
| // Provide the compiled function's source by its `toString` method or |
| // the `source` property as a convenience for inlining compiled templates. |
| result.source = source; |
| if (isError(result)) { |
| throw result; |
| } |
| return result; |
| } |
| /** |
| * Removes leading and trailing whitespace or specified characters from `string`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to trim. |
| * @param {string} [chars=whitespace] The characters to trim. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {string} Returns the trimmed string. |
| * @example |
| * |
| * _.trim(' abc '); |
| * // => 'abc' |
| * |
| * _.trim('-_-abc-_-', '_-'); |
| * // => 'abc' |
| * |
| * _.map([' foo ', ' bar '], _.trim); |
| * // => ['foo', 'bar'] |
| */ |
| function trim(string, chars, guard) { |
| var value = string; |
| string = baseToString(string); |
| if (!string) { |
| return string; |
| } |
| if (guard ? isIterateeCall(value, chars, guard) : chars == null) { |
| return string.slice(trimmedLeftIndex(string), trimmedRightIndex(string) + 1); |
| } |
| chars = chars + ''; |
| return string.slice(charsLeftIndex(string, chars), charsRightIndex(string, chars) + 1); |
| } |
| /** |
| * Removes leading whitespace or specified characters from `string`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to trim. |
| * @param {string} [chars=whitespace] The characters to trim. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {string} Returns the trimmed string. |
| * @example |
| * |
| * _.trimLeft(' abc '); |
| * // => 'abc ' |
| * |
| * _.trimLeft('-_-abc-_-', '_-'); |
| * // => 'abc-_-' |
| */ |
| function trimLeft(string, chars, guard) { |
| var value = string; |
| string = baseToString(string); |
| if (!string) { |
| return string; |
| } |
| if (guard ? isIterateeCall(value, chars, guard) : chars == null) { |
| return string.slice(trimmedLeftIndex(string)); |
| } |
| return string.slice(charsLeftIndex(string, chars + '')); |
| } |
| /** |
| * Removes trailing whitespace or specified characters from `string`. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to trim. |
| * @param {string} [chars=whitespace] The characters to trim. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {string} Returns the trimmed string. |
| * @example |
| * |
| * _.trimRight(' abc '); |
| * // => ' abc' |
| * |
| * _.trimRight('-_-abc-_-', '_-'); |
| * // => '-_-abc' |
| */ |
| function trimRight(string, chars, guard) { |
| var value = string; |
| string = baseToString(string); |
| if (!string) { |
| return string; |
| } |
| if (guard ? isIterateeCall(value, chars, guard) : chars == null) { |
| return string.slice(0, trimmedRightIndex(string) + 1); |
| } |
| return string.slice(0, charsRightIndex(string, chars + '') + 1); |
| } |
| /** |
| * Truncates `string` if it's longer than the given maximum string length. |
| * The last characters of the truncated string are replaced with the omission |
| * string which defaults to "...". |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to truncate. |
| * @param {Object|number} [options] The options object or maximum string length. |
| * @param {number} [options.length=30] The maximum string length. |
| * @param {string} [options.omission='...'] The string to indicate text is omitted. |
| * @param {RegExp|string} [options.separator] The separator pattern to truncate to. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {string} Returns the truncated string. |
| * @example |
| * |
| * _.trunc('hi-diddly-ho there, neighborino'); |
| * // => 'hi-diddly-ho there, neighbo...' |
| * |
| * _.trunc('hi-diddly-ho there, neighborino', 24); |
| * // => 'hi-diddly-ho there, n...' |
| * |
| * _.trunc('hi-diddly-ho there, neighborino', { |
| * 'length': 24, |
| * 'separator': ' ' |
| * }); |
| * // => 'hi-diddly-ho there,...' |
| * |
| * _.trunc('hi-diddly-ho there, neighborino', { |
| * 'length': 24, |
| * 'separator': /,? +/ |
| * }); |
| * // => 'hi-diddly-ho there...' |
| * |
| * _.trunc('hi-diddly-ho there, neighborino', { |
| * 'omission': ' [...]' |
| * }); |
| * // => 'hi-diddly-ho there, neig [...]' |
| */ |
| function trunc(string, options, guard) { |
| if (guard && isIterateeCall(string, options, guard)) { |
| options = undefined; |
| } |
| var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION; |
| if (options != null) { |
| if (isObject(options)) { |
| var separator = 'separator' in options ? options.separator : separator; |
| length = 'length' in options ? +options.length || 0 : length; |
| omission = 'omission' in options ? baseToString(options.omission) : omission; |
| } else { |
| length = +options || 0; |
| } |
| } |
| string = baseToString(string); |
| if (length >= string.length) { |
| return string; |
| } |
| var end = length - omission.length; |
| if (end < 1) { |
| return omission; |
| } |
| var result = string.slice(0, end); |
| if (separator == null) { |
| return result + omission; |
| } |
| if (isRegExp(separator)) { |
| if (string.slice(end).search(separator)) { |
| var match, newEnd, substring = string.slice(0, end); |
| if (!separator.global) { |
| separator = RegExp(separator.source, (reFlags.exec(separator) || '') + 'g'); |
| } |
| separator.lastIndex = 0; |
| while (match = separator.exec(substring)) { |
| newEnd = match.index; |
| } |
| result = result.slice(0, newEnd == null ? end : newEnd); |
| } |
| } else if (string.indexOf(separator, end) != end) { |
| var index = result.lastIndexOf(separator); |
| if (index > -1) { |
| result = result.slice(0, index); |
| } |
| } |
| return result + omission; |
| } |
| /** |
| * The inverse of `_.escape`; this method converts the HTML entities |
| * `&`, `<`, `>`, `"`, `'`, and ``` in `string` to their |
| * corresponding characters. |
| * |
| * **Note:** No other HTML entities are unescaped. To unescape additional HTML |
| * entities use a third-party library like [_he_](https://mths.be/he). |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to unescape. |
| * @returns {string} Returns the unescaped string. |
| * @example |
| * |
| * _.unescape('fred, barney, & pebbles'); |
| * // => 'fred, barney, & pebbles' |
| */ |
| function unescape(string) { |
| string = baseToString(string); |
| return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string; |
| } |
| /** |
| * Splits `string` into an array of its words. |
| * |
| * @static |
| * @memberOf _ |
| * @category String |
| * @param {string} [string=''] The string to inspect. |
| * @param {RegExp|string} [pattern] The pattern to match words. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Array} Returns the words of `string`. |
| * @example |
| * |
| * _.words('fred, barney, & pebbles'); |
| * // => ['fred', 'barney', 'pebbles'] |
| * |
| * _.words('fred, barney, & pebbles', /[^, ]+/g); |
| * // => ['fred', 'barney', '&', 'pebbles'] |
| */ |
| function words(string, pattern, guard) { |
| if (guard && isIterateeCall(string, pattern, guard)) { |
| pattern = undefined; |
| } |
| string = baseToString(string); |
| return string.match(pattern || reWords) || []; |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Attempts to invoke `func`, returning either the result or the caught error |
| * object. Any additional arguments are provided to `func` when it's invoked. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Function} func The function to attempt. |
| * @returns {*} Returns the `func` result or error object. |
| * @example |
| * |
| * // avoid throwing errors for invalid selectors |
| * var elements = _.attempt(function(selector) { |
| * return document.querySelectorAll(selector); |
| * }, '>_>'); |
| * |
| * if (_.isError(elements)) { |
| * elements = []; |
| * } |
| */ |
| var attempt = restParam(function (func, args) { |
| try { |
| return func.apply(undefined, args); |
| } catch (e) { |
| return isError(e) ? e : new Error(e); |
| } |
| }); |
| /** |
| * Creates a function that invokes `func` with the `this` binding of `thisArg` |
| * and arguments of the created function. If `func` is a property name the |
| * created callback returns the property value for a given element. If `func` |
| * is an object the created callback returns `true` for elements that contain |
| * the equivalent object properties, otherwise it returns `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @alias iteratee |
| * @category Utility |
| * @param {*} [func=_.identity] The value to convert to a callback. |
| * @param {*} [thisArg] The `this` binding of `func`. |
| * @param- {Object} [guard] Enables use as a callback for functions like `_.map`. |
| * @returns {Function} Returns the callback. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 } |
| * ]; |
| * |
| * // wrap to create custom callback shorthands |
| * _.callback = _.wrap(_.callback, function(callback, func, thisArg) { |
| * var match = /^(.+?)__([gl]t)(.+)$/.exec(func); |
| * if (!match) { |
| * return callback(func, thisArg); |
| * } |
| * return function(object) { |
| * return match[2] == 'gt' |
| * ? object[match[1]] > match[3] |
| * : object[match[1]] < match[3]; |
| * }; |
| * }); |
| * |
| * _.filter(users, 'age__gt36'); |
| * // => [{ 'user': 'fred', 'age': 40 }] |
| */ |
| function callback(func, thisArg, guard) { |
| if (guard && isIterateeCall(func, thisArg, guard)) { |
| thisArg = undefined; |
| } |
| return isObjectLike(func) ? matches(func) : baseCallback(func, thisArg); |
| } |
| /** |
| * Creates a function that returns `value`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {*} value The value to return from the new function. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * var getter = _.constant(object); |
| * |
| * getter() === object; |
| * // => true |
| */ |
| function constant(value) { |
| return function () { |
| return value; |
| }; |
| } |
| /** |
| * This method returns the first argument provided to it. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {*} value Any value. |
| * @returns {*} Returns `value`. |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * |
| * _.identity(object) === object; |
| * // => true |
| */ |
| function identity(value) { |
| return value; |
| } |
| /** |
| * Creates a function that performs a deep comparison between a given object |
| * and `source`, returning `true` if the given object has equivalent property |
| * values, else `false`. |
| * |
| * **Note:** This method supports comparing arrays, booleans, `Date` objects, |
| * numbers, `Object` objects, regexes, and strings. Objects are compared by |
| * their own, not inherited, enumerable properties. For comparing a single |
| * own or inherited property value see `_.matchesProperty`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Object} source The object of property values to match. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36, 'active': true }, |
| * { 'user': 'fred', 'age': 40, 'active': false } |
| * ]; |
| * |
| * _.filter(users, _.matches({ 'age': 40, 'active': false })); |
| * // => [{ 'user': 'fred', 'age': 40, 'active': false }] |
| */ |
| function matches(source) { |
| return baseMatches(baseClone(source, true)); |
| } |
| /** |
| * Creates a function that compares the property value of `path` on a given |
| * object to `value`. |
| * |
| * **Note:** This method supports comparing arrays, booleans, `Date` objects, |
| * numbers, `Object` objects, regexes, and strings. Objects are compared by |
| * their own, not inherited, enumerable properties. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Array|string} path The path of the property to get. |
| * @param {*} srcValue The value to match. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var users = [ |
| * { 'user': 'barney' }, |
| * { 'user': 'fred' } |
| * ]; |
| * |
| * _.find(users, _.matchesProperty('user', 'fred')); |
| * // => { 'user': 'fred' } |
| */ |
| function matchesProperty(path, srcValue) { |
| return baseMatchesProperty(path, baseClone(srcValue, true)); |
| } |
| /** |
| * Creates a function that invokes the method at `path` on a given object. |
| * Any additional arguments are provided to the invoked method. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Array|string} path The path of the method to invoke. |
| * @param {...*} [args] The arguments to invoke the method with. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var objects = [ |
| * { 'a': { 'b': { 'c': _.constant(2) } } }, |
| * { 'a': { 'b': { 'c': _.constant(1) } } } |
| * ]; |
| * |
| * _.map(objects, _.method('a.b.c')); |
| * // => [2, 1] |
| * |
| * _.invoke(_.sortBy(objects, _.method(['a', 'b', 'c'])), 'a.b.c'); |
| * // => [1, 2] |
| */ |
| var method = restParam(function (path, args) { |
| return function (object) { |
| return invokePath(object, path, args); |
| }; |
| }); |
| /** |
| * The opposite of `_.method`; this method creates a function that invokes |
| * the method at a given path on `object`. Any additional arguments are |
| * provided to the invoked method. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Object} object The object to query. |
| * @param {...*} [args] The arguments to invoke the method with. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var array = _.times(3, _.constant), |
| * object = { 'a': array, 'b': array, 'c': array }; |
| * |
| * _.map(['a[2]', 'c[0]'], _.methodOf(object)); |
| * // => [2, 0] |
| * |
| * _.map([['a', '2'], ['c', '0']], _.methodOf(object)); |
| * // => [2, 0] |
| */ |
| var methodOf = restParam(function (object, args) { |
| return function (path) { |
| return invokePath(object, path, args); |
| }; |
| }); |
| /** |
| * Adds all own enumerable function properties of a source object to the |
| * destination object. If `object` is a function then methods are added to |
| * its prototype as well. |
| * |
| * **Note:** Use `_.runInContext` to create a pristine `lodash` function to |
| * avoid conflicts caused by modifying the original. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Function|Object} [object=lodash] The destination object. |
| * @param {Object} source The object of functions to add. |
| * @param {Object} [options] The options object. |
| * @param {boolean} [options.chain=true] Specify whether the functions added |
| * are chainable. |
| * @returns {Function|Object} Returns `object`. |
| * @example |
| * |
| * function vowels(string) { |
| * return _.filter(string, function(v) { |
| * return /[aeiou]/i.test(v); |
| * }); |
| * } |
| * |
| * _.mixin({ 'vowels': vowels }); |
| * _.vowels('fred'); |
| * // => ['e'] |
| * |
| * _('fred').vowels().value(); |
| * // => ['e'] |
| * |
| * _.mixin({ 'vowels': vowels }, { 'chain': false }); |
| * _('fred').vowels(); |
| * // => ['e'] |
| */ |
| function mixin(object, source, options) { |
| if (options == null) { |
| var isObj = isObject(source), props = isObj ? keys(source) : undefined, methodNames = props && props.length ? baseFunctions(source, props) : undefined; |
| if (!(methodNames ? methodNames.length : isObj)) { |
| methodNames = false; |
| options = source; |
| source = object; |
| object = this; |
| } |
| } |
| if (!methodNames) { |
| methodNames = baseFunctions(source, keys(source)); |
| } |
| var chain = true, index = -1, isFunc = isFunction(object), length = methodNames.length; |
| if (options === false) { |
| chain = false; |
| } else if (isObject(options) && 'chain' in options) { |
| chain = options.chain; |
| } |
| while (++index < length) { |
| var methodName = methodNames[index], func = source[methodName]; |
| object[methodName] = func; |
| if (isFunc) { |
| object.prototype[methodName] = function (func) { |
| return function () { |
| var chainAll = this.__chain__; |
| if (chain || chainAll) { |
| var result = object(this.__wrapped__), actions = result.__actions__ = arrayCopy(this.__actions__); |
| actions.push({ |
| 'func': func, |
| 'args': arguments, |
| 'thisArg': object |
| }); |
| result.__chain__ = chainAll; |
| return result; |
| } |
| return func.apply(object, arrayPush([this.value()], arguments)); |
| }; |
| }(func); |
| } |
| } |
| return object; |
| } |
| /** |
| * Reverts the `_` variable to its previous value and returns a reference to |
| * the `lodash` function. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @returns {Function} Returns the `lodash` function. |
| * @example |
| * |
| * var lodash = _.noConflict(); |
| */ |
| function noConflict() { |
| root._ = oldDash; |
| return this; |
| } |
| /** |
| * A no-operation function that returns `undefined` regardless of the |
| * arguments it receives. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @example |
| * |
| * var object = { 'user': 'fred' }; |
| * |
| * _.noop(object) === undefined; |
| * // => true |
| */ |
| function noop() { |
| } |
| /** |
| * Creates a function that returns the property value at `path` on a |
| * given object. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Array|string} path The path of the property to get. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var objects = [ |
| * { 'a': { 'b': { 'c': 2 } } }, |
| * { 'a': { 'b': { 'c': 1 } } } |
| * ]; |
| * |
| * _.map(objects, _.property('a.b.c')); |
| * // => [2, 1] |
| * |
| * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c'); |
| * // => [1, 2] |
| */ |
| function property(path) { |
| return isKey(path) ? baseProperty(path) : basePropertyDeep(path); |
| } |
| /** |
| * The opposite of `_.property`; this method creates a function that returns |
| * the property value at a given path on `object`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {Object} object The object to query. |
| * @returns {Function} Returns the new function. |
| * @example |
| * |
| * var array = [0, 1, 2], |
| * object = { 'a': array, 'b': array, 'c': array }; |
| * |
| * _.map(['a[2]', 'c[0]'], _.propertyOf(object)); |
| * // => [2, 0] |
| * |
| * _.map([['a', '2'], ['c', '0']], _.propertyOf(object)); |
| * // => [2, 0] |
| */ |
| function propertyOf(object) { |
| return function (path) { |
| return baseGet(object, toPath(path), path + ''); |
| }; |
| } |
| /** |
| * Creates an array of numbers (positive and/or negative) progressing from |
| * `start` up to, but not including, `end`. If `end` is not specified it's |
| * set to `start` with `start` then set to `0`. If `end` is less than `start` |
| * a zero-length range is created unless a negative `step` is specified. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {number} [start=0] The start of the range. |
| * @param {number} end The end of the range. |
| * @param {number} [step=1] The value to increment or decrement by. |
| * @returns {Array} Returns the new array of numbers. |
| * @example |
| * |
| * _.range(4); |
| * // => [0, 1, 2, 3] |
| * |
| * _.range(1, 5); |
| * // => [1, 2, 3, 4] |
| * |
| * _.range(0, 20, 5); |
| * // => [0, 5, 10, 15] |
| * |
| * _.range(0, -4, -1); |
| * // => [0, -1, -2, -3] |
| * |
| * _.range(1, 4, 0); |
| * // => [1, 1, 1] |
| * |
| * _.range(0); |
| * // => [] |
| */ |
| function range(start, end, step) { |
| if (step && isIterateeCall(start, end, step)) { |
| end = step = undefined; |
| } |
| start = +start || 0; |
| step = step == null ? 1 : +step || 0; |
| if (end == null) { |
| end = start; |
| start = 0; |
| } else { |
| end = +end || 0; |
| } |
| // Use `Array(length)` so engines like Chakra and V8 avoid slower modes. |
| // See https://youtu.be/XAqIpGU8ZZk#t=17m25s for more details. |
| var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result = Array(length); |
| while (++index < length) { |
| result[index] = start; |
| start += step; |
| } |
| return result; |
| } |
| /** |
| * Invokes the iteratee function `n` times, returning an array of the results |
| * of each invocation. The `iteratee` is bound to `thisArg` and invoked with |
| * one argument; (index). |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {number} n The number of times to invoke `iteratee`. |
| * @param {Function} [iteratee=_.identity] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {Array} Returns the array of results. |
| * @example |
| * |
| * var diceRolls = _.times(3, _.partial(_.random, 1, 6, false)); |
| * // => [3, 6, 4] |
| * |
| * _.times(3, function(n) { |
| * mage.castSpell(n); |
| * }); |
| * // => invokes `mage.castSpell(n)` three times with `n` of `0`, `1`, and `2` |
| * |
| * _.times(3, function(n) { |
| * this.cast(n); |
| * }, mage); |
| * // => also invokes `mage.castSpell(n)` three times |
| */ |
| function times(n, iteratee, thisArg) { |
| n = nativeFloor(n); |
| // Exit early to avoid a JSC JIT bug in Safari 8 |
| // where `Array(0)` is treated as `Array(1)`. |
| if (n < 1 || !nativeIsFinite(n)) { |
| return []; |
| } |
| var index = -1, result = Array(nativeMin(n, MAX_ARRAY_LENGTH)); |
| iteratee = bindCallback(iteratee, thisArg, 1); |
| while (++index < n) { |
| if (index < MAX_ARRAY_LENGTH) { |
| result[index] = iteratee(index); |
| } else { |
| iteratee(index); |
| } |
| } |
| return result; |
| } |
| /** |
| * Generates a unique ID. If `prefix` is provided the ID is appended to it. |
| * |
| * @static |
| * @memberOf _ |
| * @category Utility |
| * @param {string} [prefix] The value to prefix the ID with. |
| * @returns {string} Returns the unique ID. |
| * @example |
| * |
| * _.uniqueId('contact_'); |
| * // => 'contact_104' |
| * |
| * _.uniqueId(); |
| * // => '105' |
| */ |
| function uniqueId(prefix) { |
| var id = ++idCounter; |
| return baseToString(prefix) + id; |
| } |
| /*------------------------------------------------------------------------*/ |
| /** |
| * Adds two numbers. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {number} augend The first number to add. |
| * @param {number} addend The second number to add. |
| * @returns {number} Returns the sum. |
| * @example |
| * |
| * _.add(6, 4); |
| * // => 10 |
| */ |
| function add(augend, addend) { |
| return (+augend || 0) + (+addend || 0); |
| } |
| /** |
| * Calculates `n` rounded up to `precision`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {number} n The number to round up. |
| * @param {number} [precision=0] The precision to round up to. |
| * @returns {number} Returns the rounded up number. |
| * @example |
| * |
| * _.ceil(4.006); |
| * // => 5 |
| * |
| * _.ceil(6.004, 2); |
| * // => 6.01 |
| * |
| * _.ceil(6040, -2); |
| * // => 6100 |
| */ |
| var ceil = createRound('ceil'); |
| /** |
| * Calculates `n` rounded down to `precision`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {number} n The number to round down. |
| * @param {number} [precision=0] The precision to round down to. |
| * @returns {number} Returns the rounded down number. |
| * @example |
| * |
| * _.floor(4.006); |
| * // => 4 |
| * |
| * _.floor(0.046, 2); |
| * // => 0.04 |
| * |
| * _.floor(4060, -2); |
| * // => 4000 |
| */ |
| var floor = createRound('floor'); |
| /** |
| * Gets the maximum value of `collection`. If `collection` is empty or falsey |
| * `-Infinity` is returned. If an iteratee function is provided it's invoked |
| * for each value in `collection` to generate the criterion by which the value |
| * is ranked. The `iteratee` is bound to `thisArg` and invoked with three |
| * arguments: (value, index, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {*} Returns the maximum value. |
| * @example |
| * |
| * _.max([4, 2, 8, 6]); |
| * // => 8 |
| * |
| * _.max([]); |
| * // => -Infinity |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 } |
| * ]; |
| * |
| * _.max(users, function(chr) { |
| * return chr.age; |
| * }); |
| * // => { 'user': 'fred', 'age': 40 } |
| * |
| * // using the `_.property` callback shorthand |
| * _.max(users, 'age'); |
| * // => { 'user': 'fred', 'age': 40 } |
| */ |
| var max = createExtremum(gt, NEGATIVE_INFINITY); |
| /** |
| * Gets the minimum value of `collection`. If `collection` is empty or falsey |
| * `Infinity` is returned. If an iteratee function is provided it's invoked |
| * for each value in `collection` to generate the criterion by which the value |
| * is ranked. The `iteratee` is bound to `thisArg` and invoked with three |
| * arguments: (value, index, collection). |
| * |
| * If a property name is provided for `iteratee` the created `_.property` |
| * style callback returns the property value of the given element. |
| * |
| * If a value is also provided for `thisArg` the created `_.matchesProperty` |
| * style callback returns `true` for elements that have a matching property |
| * value, else `false`. |
| * |
| * If an object is provided for `iteratee` the created `_.matches` style |
| * callback returns `true` for elements that have the properties of the given |
| * object, else `false`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {*} Returns the minimum value. |
| * @example |
| * |
| * _.min([4, 2, 8, 6]); |
| * // => 2 |
| * |
| * _.min([]); |
| * // => Infinity |
| * |
| * var users = [ |
| * { 'user': 'barney', 'age': 36 }, |
| * { 'user': 'fred', 'age': 40 } |
| * ]; |
| * |
| * _.min(users, function(chr) { |
| * return chr.age; |
| * }); |
| * // => { 'user': 'barney', 'age': 36 } |
| * |
| * // using the `_.property` callback shorthand |
| * _.min(users, 'age'); |
| * // => { 'user': 'barney', 'age': 36 } |
| */ |
| var min = createExtremum(lt, POSITIVE_INFINITY); |
| /** |
| * Calculates `n` rounded to `precision`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {number} n The number to round. |
| * @param {number} [precision=0] The precision to round to. |
| * @returns {number} Returns the rounded number. |
| * @example |
| * |
| * _.round(4.006); |
| * // => 4 |
| * |
| * _.round(4.006, 2); |
| * // => 4.01 |
| * |
| * _.round(4060, -2); |
| * // => 4100 |
| */ |
| var round = createRound('round'); |
| /** |
| * Gets the sum of the values in `collection`. |
| * |
| * @static |
| * @memberOf _ |
| * @category Math |
| * @param {Array|Object|string} collection The collection to iterate over. |
| * @param {Function|Object|string} [iteratee] The function invoked per iteration. |
| * @param {*} [thisArg] The `this` binding of `iteratee`. |
| * @returns {number} Returns the sum. |
| * @example |
| * |
| * _.sum([4, 6]); |
| * // => 10 |
| * |
| * _.sum({ 'a': 4, 'b': 6 }); |
| * // => 10 |
| * |
| * var objects = [ |
| * { 'n': 4 }, |
| * { 'n': 6 } |
| * ]; |
| * |
| * _.sum(objects, function(object) { |
| * return object.n; |
| * }); |
| * // => 10 |
| * |
| * // using the `_.property` callback shorthand |
| * _.sum(objects, 'n'); |
| * // => 10 |
| */ |
| function sum(collection, iteratee, thisArg) { |
| if (thisArg && isIterateeCall(collection, iteratee, thisArg)) { |
| iteratee = undefined; |
| } |
| iteratee = getCallback(iteratee, thisArg, 3); |
| return iteratee.length == 1 ? arraySum(isArray(collection) ? collection : toIterable(collection), iteratee) : baseSum(collection, iteratee); |
| } |
| /*------------------------------------------------------------------------*/ |
| // Ensure wrappers are instances of `baseLodash`. |
| lodash.prototype = baseLodash.prototype; |
| LodashWrapper.prototype = baseCreate(baseLodash.prototype); |
| LodashWrapper.prototype.constructor = LodashWrapper; |
| LazyWrapper.prototype = baseCreate(baseLodash.prototype); |
| LazyWrapper.prototype.constructor = LazyWrapper; |
| // Add functions to the `Map` cache. |
| MapCache.prototype['delete'] = mapDelete; |
| MapCache.prototype.get = mapGet; |
| MapCache.prototype.has = mapHas; |
| MapCache.prototype.set = mapSet; |
| // Add functions to the `Set` cache. |
| SetCache.prototype.push = cachePush; |
| // Assign cache to `_.memoize`. |
| memoize.Cache = MapCache; |
| // Add functions that return wrapped values when chaining. |
| lodash.after = after; |
| lodash.ary = ary; |
| lodash.assign = assign; |
| lodash.at = at; |
| lodash.before = before; |
| lodash.bind = bind; |
| lodash.bindAll = bindAll; |
| lodash.bindKey = bindKey; |
| lodash.callback = callback; |
| lodash.chain = chain; |
| lodash.chunk = chunk; |
| lodash.compact = compact; |
| lodash.constant = constant; |
| lodash.countBy = countBy; |
| lodash.create = create; |
| lodash.curry = curry; |
| lodash.curryRight = curryRight; |
| lodash.debounce = debounce; |
| lodash.defaults = defaults; |
| lodash.defaultsDeep = defaultsDeep; |
| lodash.defer = defer; |
| lodash.delay = delay; |
| lodash.difference = difference; |
| lodash.drop = drop; |
| lodash.dropRight = dropRight; |
| lodash.dropRightWhile = dropRightWhile; |
| lodash.dropWhile = dropWhile; |
| lodash.fill = fill; |
| lodash.filter = filter; |
| lodash.flatten = flatten; |
| lodash.flattenDeep = flattenDeep; |
| lodash.flow = flow; |
| lodash.flowRight = flowRight; |
| lodash.forEach = forEach; |
| lodash.forEachRight = forEachRight; |
| lodash.forIn = forIn; |
| lodash.forInRight = forInRight; |
| lodash.forOwn = forOwn; |
| lodash.forOwnRight = forOwnRight; |
| lodash.functions = functions; |
| lodash.groupBy = groupBy; |
| lodash.indexBy = indexBy; |
| lodash.initial = initial; |
| lodash.intersection = intersection; |
| lodash.invert = invert; |
| lodash.invoke = invoke; |
| lodash.keys = keys; |
| lodash.keysIn = keysIn; |
| lodash.map = map; |
| lodash.mapKeys = mapKeys; |
| lodash.mapValues = mapValues; |
| lodash.matches = matches; |
| lodash.matchesProperty = matchesProperty; |
| lodash.memoize = memoize; |
| lodash.merge = merge; |
| lodash.method = method; |
| lodash.methodOf = methodOf; |
| lodash.mixin = mixin; |
| lodash.modArgs = modArgs; |
| lodash.negate = negate; |
| lodash.omit = omit; |
| lodash.once = once; |
| lodash.pairs = pairs; |
| lodash.partial = partial; |
| lodash.partialRight = partialRight; |
| lodash.partition = partition; |
| lodash.pick = pick; |
| lodash.pluck = pluck; |
| lodash.property = property; |
| lodash.propertyOf = propertyOf; |
| lodash.pull = pull; |
| lodash.pullAt = pullAt; |
| lodash.range = range; |
| lodash.rearg = rearg; |
| lodash.reject = reject; |
| lodash.remove = remove; |
| lodash.rest = rest; |
| lodash.restParam = restParam; |
| lodash.set = set; |
| lodash.shuffle = shuffle; |
| lodash.slice = slice; |
| lodash.sortBy = sortBy; |
| lodash.sortByAll = sortByAll; |
| lodash.sortByOrder = sortByOrder; |
| lodash.spread = spread; |
| lodash.take = take; |
| lodash.takeRight = takeRight; |
| lodash.takeRightWhile = takeRightWhile; |
| lodash.takeWhile = takeWhile; |
| lodash.tap = tap; |
| lodash.throttle = throttle; |
| lodash.thru = thru; |
| lodash.times = times; |
| lodash.toArray = toArray; |
| lodash.toPlainObject = toPlainObject; |
| lodash.transform = transform; |
| lodash.union = union; |
| lodash.uniq = uniq; |
| lodash.unzip = unzip; |
| lodash.unzipWith = unzipWith; |
| lodash.values = values; |
| lodash.valuesIn = valuesIn; |
| lodash.where = where; |
| lodash.without = without; |
| lodash.wrap = wrap; |
| lodash.xor = xor; |
| lodash.zip = zip; |
| lodash.zipObject = zipObject; |
| lodash.zipWith = zipWith; |
| // Add aliases. |
| lodash.backflow = flowRight; |
| lodash.collect = map; |
| lodash.compose = flowRight; |
| lodash.each = forEach; |
| lodash.eachRight = forEachRight; |
| lodash.extend = assign; |
| lodash.iteratee = callback; |
| lodash.methods = functions; |
| lodash.object = zipObject; |
| lodash.select = filter; |
| lodash.tail = rest; |
| lodash.unique = uniq; |
| // Add functions to `lodash.prototype`. |
| mixin(lodash, lodash); |
| /*------------------------------------------------------------------------*/ |
| // Add functions that return unwrapped values when chaining. |
| lodash.add = add; |
| lodash.attempt = attempt; |
| lodash.camelCase = camelCase; |
| lodash.capitalize = capitalize; |
| lodash.ceil = ceil; |
| lodash.clone = clone; |
| lodash.cloneDeep = cloneDeep; |
| lodash.deburr = deburr; |
| lodash.endsWith = endsWith; |
| lodash.escape = escape; |
| lodash.escapeRegExp = escapeRegExp; |
| lodash.every = every; |
| lodash.find = find; |
| lodash.findIndex = findIndex; |
| lodash.findKey = findKey; |
| lodash.findLast = findLast; |
| lodash.findLastIndex = findLastIndex; |
| lodash.findLastKey = findLastKey; |
| lodash.findWhere = findWhere; |
| lodash.first = first; |
| lodash.floor = floor; |
| lodash.get = get; |
| lodash.gt = gt; |
| lodash.gte = gte; |
| lodash.has = has; |
| lodash.identity = identity; |
| lodash.includes = includes; |
| lodash.indexOf = indexOf; |
| lodash.inRange = inRange; |
| lodash.isArguments = isArguments; |
| lodash.isArray = isArray; |
| lodash.isBoolean = isBoolean; |
| lodash.isDate = isDate; |
| lodash.isElement = isElement; |
| lodash.isEmpty = isEmpty; |
| lodash.isEqual = isEqual; |
| lodash.isError = isError; |
| lodash.isFinite = isFinite; |
| lodash.isFunction = isFunction; |
| lodash.isMatch = isMatch; |
| lodash.isNaN = isNaN; |
| lodash.isNative = isNative; |
| lodash.isNull = isNull; |
| lodash.isNumber = isNumber; |
| lodash.isObject = isObject; |
| lodash.isPlainObject = isPlainObject; |
| lodash.isRegExp = isRegExp; |
| lodash.isString = isString; |
| lodash.isTypedArray = isTypedArray; |
| lodash.isUndefined = isUndefined; |
| lodash.kebabCase = kebabCase; |
| lodash.last = last; |
| lodash.lastIndexOf = lastIndexOf; |
| lodash.lt = lt; |
| lodash.lte = lte; |
| lodash.max = max; |
| lodash.min = min; |
| lodash.noConflict = noConflict; |
| lodash.noop = noop; |
| lodash.now = now; |
| lodash.pad = pad; |
| lodash.padLeft = padLeft; |
| lodash.padRight = padRight; |
| lodash.parseInt = parseInt; |
| lodash.random = random; |
| lodash.reduce = reduce; |
| lodash.reduceRight = reduceRight; |
| lodash.repeat = repeat; |
| lodash.result = result; |
| lodash.round = round; |
| lodash.runInContext = runInContext; |
| lodash.size = size; |
| lodash.snakeCase = snakeCase; |
| lodash.some = some; |
| lodash.sortedIndex = sortedIndex; |
| lodash.sortedLastIndex = sortedLastIndex; |
| lodash.startCase = startCase; |
| lodash.startsWith = startsWith; |
| lodash.sum = sum; |
| lodash.template = template; |
| lodash.trim = trim; |
| lodash.trimLeft = trimLeft; |
| lodash.trimRight = trimRight; |
| lodash.trunc = trunc; |
| lodash.unescape = unescape; |
| lodash.uniqueId = uniqueId; |
| lodash.words = words; |
| // Add aliases. |
| lodash.all = every; |
| lodash.any = some; |
| lodash.contains = includes; |
| lodash.eq = isEqual; |
| lodash.detect = find; |
| lodash.foldl = reduce; |
| lodash.foldr = reduceRight; |
| lodash.head = first; |
| lodash.include = includes; |
| lodash.inject = reduce; |
| mixin(lodash, function () { |
| var source = {}; |
| baseForOwn(lodash, function (func, methodName) { |
| if (!lodash.prototype[methodName]) { |
| source[methodName] = func; |
| } |
| }); |
| return source; |
| }(), false); |
| /*------------------------------------------------------------------------*/ |
| // Add functions capable of returning wrapped and unwrapped values when chaining. |
| lodash.sample = sample; |
| lodash.prototype.sample = function (n) { |
| if (!this.__chain__ && n == null) { |
| return sample(this.value()); |
| } |
| return this.thru(function (value) { |
| return sample(value, n); |
| }); |
| }; |
| /*------------------------------------------------------------------------*/ |
| /** |
| * The semantic version number. |
| * |
| * @static |
| * @memberOf _ |
| * @type string |
| */ |
| lodash.VERSION = VERSION; |
| // Assign default placeholders. |
| arrayEach([ |
| 'bind', |
| 'bindKey', |
| 'curry', |
| 'curryRight', |
| 'partial', |
| 'partialRight' |
| ], function (methodName) { |
| lodash[methodName].placeholder = lodash; |
| }); |
| // Add `LazyWrapper` methods for `_.drop` and `_.take` variants. |
| arrayEach([ |
| 'drop', |
| 'take' |
| ], function (methodName, index) { |
| LazyWrapper.prototype[methodName] = function (n) { |
| var filtered = this.__filtered__; |
| if (filtered && !index) { |
| return new LazyWrapper(this); |
| } |
| n = n == null ? 1 : nativeMax(nativeFloor(n) || 0, 0); |
| var result = this.clone(); |
| if (filtered) { |
| result.__takeCount__ = nativeMin(result.__takeCount__, n); |
| } else { |
| result.__views__.push({ |
| 'size': n, |
| 'type': methodName + (result.__dir__ < 0 ? 'Right' : '') |
| }); |
| } |
| return result; |
| }; |
| LazyWrapper.prototype[methodName + 'Right'] = function (n) { |
| return this.reverse()[methodName](n).reverse(); |
| }; |
| }); |
| // Add `LazyWrapper` methods that accept an `iteratee` value. |
| arrayEach([ |
| 'filter', |
| 'map', |
| 'takeWhile' |
| ], function (methodName, index) { |
| var type = index + 1, isFilter = type != LAZY_MAP_FLAG; |
| LazyWrapper.prototype[methodName] = function (iteratee, thisArg) { |
| var result = this.clone(); |
| result.__iteratees__.push({ |
| 'iteratee': getCallback(iteratee, thisArg, 1), |
| 'type': type |
| }); |
| result.__filtered__ = result.__filtered__ || isFilter; |
| return result; |
| }; |
| }); |
| // Add `LazyWrapper` methods for `_.first` and `_.last`. |
| arrayEach([ |
| 'first', |
| 'last' |
| ], function (methodName, index) { |
| var takeName = 'take' + (index ? 'Right' : ''); |
| LazyWrapper.prototype[methodName] = function () { |
| return this[takeName](1).value()[0]; |
| }; |
| }); |
| // Add `LazyWrapper` methods for `_.initial` and `_.rest`. |
| arrayEach([ |
| 'initial', |
| 'rest' |
| ], function (methodName, index) { |
| var dropName = 'drop' + (index ? '' : 'Right'); |
| LazyWrapper.prototype[methodName] = function () { |
| return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1); |
| }; |
| }); |
| // Add `LazyWrapper` methods for `_.pluck` and `_.where`. |
| arrayEach([ |
| 'pluck', |
| 'where' |
| ], function (methodName, index) { |
| var operationName = index ? 'filter' : 'map', createCallback = index ? baseMatches : property; |
| LazyWrapper.prototype[methodName] = function (value) { |
| return this[operationName](createCallback(value)); |
| }; |
| }); |
| LazyWrapper.prototype.compact = function () { |
| return this.filter(identity); |
| }; |
| LazyWrapper.prototype.reject = function (predicate, thisArg) { |
| predicate = getCallback(predicate, thisArg, 1); |
| return this.filter(function (value) { |
| return !predicate(value); |
| }); |
| }; |
| LazyWrapper.prototype.slice = function (start, end) { |
| start = start == null ? 0 : +start || 0; |
| var result = this; |
| if (result.__filtered__ && (start > 0 || end < 0)) { |
| return new LazyWrapper(result); |
| } |
| if (start < 0) { |
| result = result.takeRight(-start); |
| } else if (start) { |
| result = result.drop(start); |
| } |
| if (end !== undefined) { |
| end = +end || 0; |
| result = end < 0 ? result.dropRight(-end) : result.take(end - start); |
| } |
| return result; |
| }; |
| LazyWrapper.prototype.takeRightWhile = function (predicate, thisArg) { |
| return this.reverse().takeWhile(predicate, thisArg).reverse(); |
| }; |
| LazyWrapper.prototype.toArray = function () { |
| return this.take(POSITIVE_INFINITY); |
| }; |
| // Add `LazyWrapper` methods to `lodash.prototype`. |
| baseForOwn(LazyWrapper.prototype, function (func, methodName) { |
| var checkIteratee = /^(?:filter|map|reject)|While$/.test(methodName), retUnwrapped = /^(?:first|last)$/.test(methodName), lodashFunc = lodash[retUnwrapped ? 'take' + (methodName == 'last' ? 'Right' : '') : methodName]; |
| if (!lodashFunc) { |
| return; |
| } |
| lodash.prototype[methodName] = function () { |
| var args = retUnwrapped ? [1] : arguments, chainAll = this.__chain__, value = this.__wrapped__, isHybrid = !!this.__actions__.length, isLazy = value instanceof LazyWrapper, iteratee = args[0], useLazy = isLazy || isArray(value); |
| if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) { |
| // Avoid lazy use if the iteratee has a "length" value other than `1`. |
| isLazy = useLazy = false; |
| } |
| var interceptor = function (value) { |
| return retUnwrapped && chainAll ? lodashFunc(value, 1)[0] : lodashFunc.apply(undefined, arrayPush([value], args)); |
| }; |
| var action = { |
| 'func': thru, |
| 'args': [interceptor], |
| 'thisArg': undefined |
| }, onlyLazy = isLazy && !isHybrid; |
| if (retUnwrapped && !chainAll) { |
| if (onlyLazy) { |
| value = value.clone(); |
| value.__actions__.push(action); |
| return func.call(value); |
| } |
| return lodashFunc.call(undefined, this.value())[0]; |
| } |
| if (!retUnwrapped && useLazy) { |
| value = onlyLazy ? value : new LazyWrapper(this); |
| var result = func.apply(value, args); |
| result.__actions__.push(action); |
| return new LodashWrapper(result, chainAll); |
| } |
| return this.thru(interceptor); |
| }; |
| }); |
| // Add `Array` and `String` methods to `lodash.prototype`. |
| arrayEach([ |
| 'join', |
| 'pop', |
| 'push', |
| 'replace', |
| 'shift', |
| 'sort', |
| 'splice', |
| 'split', |
| 'unshift' |
| ], function (methodName) { |
| var func = (/^(?:replace|split)$/.test(methodName) ? stringProto : arrayProto)[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru', retUnwrapped = /^(?:join|pop|replace|shift)$/.test(methodName); |
| lodash.prototype[methodName] = function () { |
| var args = arguments; |
| if (retUnwrapped && !this.__chain__) { |
| return func.apply(this.value(), args); |
| } |
| return this[chainName](function (value) { |
| return func.apply(value, args); |
| }); |
| }; |
| }); |
| // Map minified function names to their real names. |
| baseForOwn(LazyWrapper.prototype, function (func, methodName) { |
| var lodashFunc = lodash[methodName]; |
| if (lodashFunc) { |
| var key = lodashFunc.name + '', names = realNames[key] || (realNames[key] = []); |
| names.push({ |
| 'name': methodName, |
| 'func': lodashFunc |
| }); |
| } |
| }); |
| realNames[createHybridWrapper(undefined, BIND_KEY_FLAG).name] = [{ |
| 'name': 'wrapper', |
| 'func': undefined |
| }]; |
| // Add functions to the lazy wrapper. |
| LazyWrapper.prototype.clone = lazyClone; |
| LazyWrapper.prototype.reverse = lazyReverse; |
| LazyWrapper.prototype.value = lazyValue; |
| // Add chaining functions to the `lodash` wrapper. |
| lodash.prototype.chain = wrapperChain; |
| lodash.prototype.commit = wrapperCommit; |
| lodash.prototype.concat = wrapperConcat; |
| lodash.prototype.plant = wrapperPlant; |
| lodash.prototype.reverse = wrapperReverse; |
| lodash.prototype.toString = wrapperToString; |
| lodash.prototype.run = lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue; |
| // Add function aliases to the `lodash` wrapper. |
| lodash.prototype.collect = lodash.prototype.map; |
| lodash.prototype.head = lodash.prototype.first; |
| lodash.prototype.select = lodash.prototype.filter; |
| lodash.prototype.tail = lodash.prototype.rest; |
| return lodash; |
| } |
| /*--------------------------------------------------------------------------*/ |
| // Export lodash. |
| var _ = runInContext(); |
| // Some AMD build optimizers like r.js check for condition patterns like the following: |
| if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { |
| // Define as an anonymous module so, through path mapping, it can be |
| // referenced as the "underscore" module. |
| define(function () { |
| return _; |
| }); |
| } // Check for `exports` after `define` in case a build optimizer adds an `exports` object. |
| else if (freeExports && freeModule) { |
| // Export for Node.js or RingoJS. |
| if (moduleExports) { |
| (freeModule.exports = _)._ = _; |
| } // Export for Rhino with CommonJS support. |
| else { |
| freeExports._ = _; |
| } |
| } |
| $provide.constant('lodash', _); |
| } |
| ]); |
| /** |
| * @license AngularJS v1.4.7 |
| * (c) 2010-2015 Google, Inc. http://angularjs.org |
| * License: MIT |
| */ |
| (function(window, angular, undefined) {'use strict'; |
| |
| /** |
| * @ngdoc module |
| * @name ngCookies |
| * @description |
| * |
| * # ngCookies |
| * |
| * The `ngCookies` module provides a convenient wrapper for reading and writing browser cookies. |
| * |
| * |
| * <div doc-module-components="ngCookies"></div> |
| * |
| * See {@link ngCookies.$cookies `$cookies`} for usage. |
| */ |
| |
| |
| angular.module('ngCookies', ['ng']). |
| /** |
| * @ngdoc provider |
| * @name $cookiesProvider |
| * @description |
| * Use `$cookiesProvider` to change the default behavior of the {@link ngCookies.$cookies $cookies} service. |
| * */ |
| provider('$cookies', [function $CookiesProvider() { |
| /** |
| * @ngdoc property |
| * @name $cookiesProvider#defaults |
| * @description |
| * |
| * Object containing default options to pass when setting cookies. |
| * |
| * The object may have following properties: |
| * |
| * - **path** - `{string}` - The cookie will be available only for this path and its |
| * sub-paths. By default, this would be the URL that appears in your base tag. |
| * - **domain** - `{string}` - The cookie will be available only for this domain and |
| * its sub-domains. For obvious security reasons the user agent will not accept the |
| * cookie if the current domain is not a sub domain or equals to the requested domain. |
| * - **expires** - `{string|Date}` - String of the form "Wdy, DD Mon YYYY HH:MM:SS GMT" |
| * or a Date object indicating the exact date/time this cookie will expire. |
| * - **secure** - `{boolean}` - The cookie will be available only in secured connection. |
| * |
| * Note: by default the address that appears in your `<base>` tag will be used as path. |
| * This is important so that cookies will be visible for all routes in case html5mode is enabled |
| * |
| **/ |
| var defaults = this.defaults = {}; |
| |
| function calcOptions(options) { |
| return options ? angular.extend({}, defaults, options) : defaults; |
| } |
| |
| /** |
| * @ngdoc service |
| * @name $cookies |
| * |
| * @description |
| * Provides read/write access to browser's cookies. |
| * |
| * <div class="alert alert-info"> |
| * Up until Angular 1.3, `$cookies` exposed properties that represented the |
| * current browser cookie values. In version 1.4, this behavior has changed, and |
| * `$cookies` now provides a standard api of getters, setters etc. |
| * </div> |
| * |
| * Requires the {@link ngCookies `ngCookies`} module to be installed. |
| * |
| * @example |
| * |
| * ```js |
| * angular.module('cookiesExample', ['ngCookies']) |
| * .controller('ExampleController', ['$cookies', function($cookies) { |
| * // Retrieving a cookie |
| * var favoriteCookie = $cookies.get('myFavorite'); |
| * // Setting a cookie |
| * $cookies.put('myFavorite', 'oatmeal'); |
| * }]); |
| * ``` |
| */ |
| this.$get = ['$$cookieReader', '$$cookieWriter', function($$cookieReader, $$cookieWriter) { |
| return { |
| /** |
| * @ngdoc method |
| * @name $cookies#get |
| * |
| * @description |
| * Returns the value of given cookie key |
| * |
| * @param {string} key Id to use for lookup. |
| * @returns {string} Raw cookie value. |
| */ |
| get: function(key) { |
| return $$cookieReader()[key]; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#getObject |
| * |
| * @description |
| * Returns the deserialized value of given cookie key |
| * |
| * @param {string} key Id to use for lookup. |
| * @returns {Object} Deserialized cookie value. |
| */ |
| getObject: function(key) { |
| var value = this.get(key); |
| return value ? angular.fromJson(value) : value; |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#getAll |
| * |
| * @description |
| * Returns a key value object with all the cookies |
| * |
| * @returns {Object} All cookies |
| */ |
| getAll: function() { |
| return $$cookieReader(); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#put |
| * |
| * @description |
| * Sets a value for given cookie key |
| * |
| * @param {string} key Id for the `value`. |
| * @param {string} value Raw value to be stored. |
| * @param {Object=} options Options object. |
| * See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults} |
| */ |
| put: function(key, value, options) { |
| $$cookieWriter(key, value, calcOptions(options)); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#putObject |
| * |
| * @description |
| * Serializes and sets a value for given cookie key |
| * |
| * @param {string} key Id for the `value`. |
| * @param {Object} value Value to be stored. |
| * @param {Object=} options Options object. |
| * See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults} |
| */ |
| putObject: function(key, value, options) { |
| this.put(key, angular.toJson(value), options); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookies#remove |
| * |
| * @description |
| * Remove given cookie |
| * |
| * @param {string} key Id of the key-value pair to delete. |
| * @param {Object=} options Options object. |
| * See {@link ngCookies.$cookiesProvider#defaults $cookiesProvider.defaults} |
| */ |
| remove: function(key, options) { |
| $$cookieWriter(key, undefined, calcOptions(options)); |
| } |
| }; |
| }]; |
| }]); |
| |
| angular.module('ngCookies'). |
| /** |
| * @ngdoc service |
| * @name $cookieStore |
| * @deprecated |
| * @requires $cookies |
| * |
| * @description |
| * Provides a key-value (string-object) storage, that is backed by session cookies. |
| * Objects put or retrieved from this storage are automatically serialized or |
| * deserialized by angular's toJson/fromJson. |
| * |
| * Requires the {@link ngCookies `ngCookies`} module to be installed. |
| * |
| * <div class="alert alert-danger"> |
| * **Note:** The $cookieStore service is **deprecated**. |
| * Please use the {@link ngCookies.$cookies `$cookies`} service instead. |
| * </div> |
| * |
| * @example |
| * |
| * ```js |
| * angular.module('cookieStoreExample', ['ngCookies']) |
| * .controller('ExampleController', ['$cookieStore', function($cookieStore) { |
| * // Put cookie |
| * $cookieStore.put('myFavorite','oatmeal'); |
| * // Get cookie |
| * var favoriteCookie = $cookieStore.get('myFavorite'); |
| * // Removing a cookie |
| * $cookieStore.remove('myFavorite'); |
| * }]); |
| * ``` |
| */ |
| factory('$cookieStore', ['$cookies', function($cookies) { |
| |
| return { |
| /** |
| * @ngdoc method |
| * @name $cookieStore#get |
| * |
| * @description |
| * Returns the value of given cookie key |
| * |
| * @param {string} key Id to use for lookup. |
| * @returns {Object} Deserialized cookie value, undefined if the cookie does not exist. |
| */ |
| get: function(key) { |
| return $cookies.getObject(key); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookieStore#put |
| * |
| * @description |
| * Sets a value for given cookie key |
| * |
| * @param {string} key Id for the `value`. |
| * @param {Object} value Value to be stored. |
| */ |
| put: function(key, value) { |
| $cookies.putObject(key, value); |
| }, |
| |
| /** |
| * @ngdoc method |
| * @name $cookieStore#remove |
| * |
| * @description |
| * Remove given cookie |
| * |
| * @param {string} key Id of the key-value pair to delete. |
| */ |
| remove: function(key) { |
| $cookies.remove(key); |
| } |
| }; |
| |
| }]); |
| |
| /** |
| * @name $$cookieWriter |
| * @requires $document |
| * |
| * @description |
| * This is a private service for writing cookies |
| * |
| * @param {string} name Cookie name |
| * @param {string=} value Cookie value (if undefined, cookie will be deleted) |
| * @param {Object=} options Object with options that need to be stored for the cookie. |
| */ |
| function $$CookieWriter($document, $log, $browser) { |
| var cookiePath = $browser.baseHref(); |
| var rawDocument = $document[0]; |
| |
| function buildCookieString(name, value, options) { |
| var path, expires; |
| options = options || {}; |
| expires = options.expires; |
| path = angular.isDefined(options.path) ? options.path : cookiePath; |
| if (angular.isUndefined(value)) { |
| expires = 'Thu, 01 Jan 1970 00:00:00 GMT'; |
| value = ''; |
| } |
| if (angular.isString(expires)) { |
| expires = new Date(expires); |
| } |
| |
| var str = encodeURIComponent(name) + '=' + encodeURIComponent(value); |
| str += path ? ';path=' + path : ''; |
| str += options.domain ? ';domain=' + options.domain : ''; |
| str += expires ? ';expires=' + expires.toUTCString() : ''; |
| str += options.secure ? ';secure' : ''; |
| |
| // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum: |
| // - 300 cookies |
| // - 20 cookies per unique domain |
| // - 4096 bytes per cookie |
| var cookieLength = str.length + 1; |
| if (cookieLength > 4096) { |
| $log.warn("Cookie '" + name + |
| "' possibly not set or overflowed because it was too large (" + |
| cookieLength + " > 4096 bytes)!"); |
| } |
| |
| return str; |
| } |
| |
| return function(name, value, options) { |
| rawDocument.cookie = buildCookieString(name, value, options); |
| }; |
| } |
| |
| $$CookieWriter.$inject = ['$document', '$log', '$browser']; |
| |
| angular.module('ngCookies').provider('$$cookieWriter', function $$CookieWriterProvider() { |
| this.$get = $$CookieWriter; |
| }); |
| |
| |
| })(window, window.angular); |