+ Snippet:
+
+
+ | Filter |
+ Source |
+ Rendered |
+
+
+ | linky filter |
+
+ <div ng-bind-html="snippet | linky">
</div>
+ |
+
+
+ |
+
+
+ | linky target |
+
+ <div ng-bind-html="snippetWithSingleURL | linky:'_blank'">
</div>
+ |
+
+
+ |
+
+
+ | linky custom attributes |
+
+ <div ng-bind-html="snippetWithSingleURL | linky:'_self':{rel: 'nofollow'}">
</div>
+ |
+
+
+ |
+
+
+ | no filter |
+ <div ng-bind="snippet">
</div> |
+ |
+
+
+
+
+ angular.module('linkyExample', ['ngSanitize'])
+ .controller('ExampleController', ['$scope', function($scope) {
+ $scope.snippet =
+ 'Pretty text with some links:\n' +
+ 'http://angularjs.org/,\n' +
+ 'mailto:us@somewhere.org,\n' +
+ 'another@somewhere.org,\n' +
+ 'and one more: ftp://127.0.0.1/.';
+ $scope.snippetWithSingleURL = 'http://angularjs.org/';
+ }]);
+
+
+ it('should linkify the snippet with urls', function() {
+ expect(element(by.id('linky-filter')).element(by.binding('snippet | linky')).getText()).
+ toBe('Pretty text with some links: http://angularjs.org/, us@somewhere.org, ' +
+ 'another@somewhere.org, and one more: ftp://127.0.0.1/.');
+ expect(element.all(by.css('#linky-filter a')).count()).toEqual(4);
+ });
+
+ it('should not linkify snippet without the linky filter', function() {
+ expect(element(by.id('escaped-html')).element(by.binding('snippet')).getText()).
+ toBe('Pretty text with some links: http://angularjs.org/, mailto:us@somewhere.org, ' +
+ 'another@somewhere.org, and one more: ftp://127.0.0.1/.');
+ expect(element.all(by.css('#escaped-html a')).count()).toEqual(0);
+ });
+
+ it('should update', function() {
+ element(by.model('snippet')).clear();
+ element(by.model('snippet')).sendKeys('new http://link.');
+ expect(element(by.id('linky-filter')).element(by.binding('snippet | linky')).getText()).
+ toBe('new http://link.');
+ expect(element.all(by.css('#linky-filter a')).count()).toEqual(1);
+ expect(element(by.id('escaped-html')).element(by.binding('snippet')).getText())
+ .toBe('new http://link.');
+ });
+
+ it('should work with the target property', function() {
+ expect(element(by.id('linky-target')).
+ element(by.binding("snippetWithSingleURL | linky:'_blank'")).getText()).
+ toBe('http://angularjs.org/');
+ expect(element(by.css('#linky-target a')).getAttribute('target')).toEqual('_blank');
+ });
+
+ it('should optionally add custom attributes', function() {
+ expect(element(by.id('linky-custom-attributes')).
+ element(by.binding("snippetWithSingleURL | linky:'_self':{rel: 'nofollow'}")).getText()).
+ toBe('http://angularjs.org/');
+ expect(element(by.css('#linky-custom-attributes a')).getAttribute('rel')).toEqual('nofollow');
+ });
+
+
*/
- this.useStrategy = function (strategy) {
- hasConfiguredStrategy = true;
- currentStrategy = strategy;
- return this;
- };
+ angular.module('ngSanitize').filter('linky', ['$sanitize', function ($sanitize) {
+ var LINKY_URL_REGEXP = /((ftp|https?):\/\/|(www\.)|(mailto:)?[A-Za-z0-9._%+-]+@)\S*[^\s.;,(){}<>"\u201d\u2019]/i,
+ MAILTO_REGEXP = /^mailto:/i;
+
+ var linkyMinErr = angular.$$minErr('linky');
+ var isDefined = angular.isDefined;
+ var isFunction = angular.isFunction;
+ var isObject = angular.isObject;
+ var isString = angular.isString;
+
+ return function (text, target, attributes) {
+ if (text == null || text === '') return text;
+ if (!isString(text)) throw linkyMinErr('notstring', 'Expected string but received: {0}', text);
+
+ var attributesFn = isFunction(attributes) ? attributes : isObject(attributes) ? function getAttributesObject() {
+ return attributes;
+ } : function getEmptyAttributesObject() {
+ return {};
+ };
+
+ var match;
+ var raw = text;
+ var html = [];
+ var url;
+ var i;
+ while (match = raw.match(LINKY_URL_REGEXP)) {
+ // We can not end in these as they are sometimes found at the end of the sentence
+ url = match[0];
+ // if we did not match ftp/http/www/mailto then assume mailto
+ if (!match[2] && !match[4]) {
+ url = (match[3] ? 'http://' : 'mailto:') + url;
+ }
+ i = match.index;
+ addText(raw.substr(0, i));
+ addLink(url, match[0].replace(MAILTO_REGEXP, ''));
+ raw = raw.substring(i + match[0].length);
+ }
+ addText(raw);
+ return $sanitize(html.join(''));
+
+ function addText(text) {
+ if (!text) {
+ return;
+ }
+ html.push(sanitizeText(text));
+ }
+
+ function addLink(url, text) {
+ var key,
+ linkAttributes = attributesFn(url);
+ html.push('
');
+ addText(text);
+ html.push('');
+ }
+ };
+ }]);
+})(window, window.angular);
+
+},{}],109:[function(require,module,exports){
+'use strict';
+
+require('./angular-sanitize');
+module.exports = 'ngSanitize';
+
+},{"./angular-sanitize":108}],110:[function(require,module,exports){
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+/*!
+ * angular-translate - v2.15.1 - 2017-03-04
+ *
+ * Copyright (c) 2017 The angular-translate team, Pascal Precht; Licensed MIT
+ */
+(function (root, factory) {
+ if (typeof define === 'function' && define.amd) {
+ // AMD. Register as an anonymous module unless amdModuleId is set
+ define([], function () {
+ return factory();
+ });
+ } else if ((typeof exports === 'undefined' ? 'undefined' : _typeof(exports)) === 'object') {
+ // Node. Does not work with strict CommonJS, but
+ // only CommonJS-like environments that support module.exports,
+ // like Node.
+ module.exports = factory();
+ } else {
+ factory();
+ }
+})(undefined, function () {
+
+ $translateMissingTranslationHandlerLog.$inject = ['$log'];
+ angular.module('pascalprecht.translate')
/**
* @ngdoc object
- * @name pascalprecht.translate.$translateSanitization
- * @requires $injector
+ * @name pascalprecht.translate.$translateMissingTranslationHandlerLog
* @requires $log
*
* @description
- * Sanitizes interpolation parameters and translated texts.
+ * Uses angular's `$log` service to give a warning when trying to translate a
+ * translation id which doesn't exist.
*
+ * @returns {function} Handler function
*/
- this.$get = ['$injector', '$log', function ($injector, $log) {
-
- var cachedStrategyMap = {};
-
- var applyStrategies = function (value, mode, context, selectedStrategies) {
- angular.forEach(selectedStrategies, function (selectedStrategy) {
- if (angular.isFunction(selectedStrategy)) {
- value = selectedStrategy(value, mode, context);
- } else if (angular.isFunction(strategies[selectedStrategy])) {
- value = strategies[selectedStrategy](value, mode, context);
- } else if (angular.isString(strategies[selectedStrategy])) {
- if (!cachedStrategyMap[strategies[selectedStrategy]]) {
- try {
- cachedStrategyMap[strategies[selectedStrategy]] = $injector.get(strategies[selectedStrategy]);
- } catch (e) {
- cachedStrategyMap[strategies[selectedStrategy]] = function() {};
- throw new Error('pascalprecht.translate.$translateSanitization: Unknown sanitization strategy: \'' + selectedStrategy + '\'');
- }
- }
- value = cachedStrategyMap[strategies[selectedStrategy]](value, mode, context);
- } else {
- throw new Error('pascalprecht.translate.$translateSanitization: Unknown sanitization strategy: \'' + selectedStrategy + '\'');
- }
- });
- return value;
+ .factory('$translateMissingTranslationHandlerLog', $translateMissingTranslationHandlerLog);
+
+ function $translateMissingTranslationHandlerLog($log) {
+
+ 'use strict';
+
+ return function (translationId) {
+ $log.warn('Translation for ' + translationId + ' doesn\'t exist');
};
+ }
+
+ $translateMissingTranslationHandlerLog.displayName = '$translateMissingTranslationHandlerLog';
+ return 'pascalprecht.translate';
+});
+
+},{}],111:[function(require,module,exports){
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+/*!
+ * angular-translate - v2.15.1 - 2017-03-04
+ *
+ * Copyright (c) 2017 The angular-translate team, Pascal Precht; Licensed MIT
+ */
+(function (root, factory) {
+ if (typeof define === 'function' && define.amd) {
+ // AMD. Register as an anonymous module unless amdModuleId is set
+ define([], function () {
+ return factory();
+ });
+ } else if ((typeof exports === 'undefined' ? 'undefined' : _typeof(exports)) === 'object') {
+ // Node. Does not work with strict CommonJS, but
+ // only CommonJS-like environments that support module.exports,
+ // like Node.
+ module.exports = factory();
+ } else {
+ factory();
+ }
+})(undefined, function () {
- // TODO: should be removed in 3.0
- var showNoStrategyConfiguredWarning = function () {
- if (!hasConfiguredStrategy && !hasShownNoStrategyConfiguredWarning) {
- $log.warn('pascalprecht.translate.$translateSanitization: No sanitization strategy has been configured. This can have serious security implications. See http://angular-translate.github.io/docs/#/guide/19_security for details.');
- hasShownNoStrategyConfiguredWarning = true;
+ /**
+ * @ngdoc overview
+ * @name pascalprecht.translate
+ *
+ * @description
+ * The main module which holds everything together.
+ */
+ runTranslate.$inject = ['$translate'];
+ $translate.$inject = ['$STORAGE_KEY', '$windowProvider', '$translateSanitizationProvider', 'pascalprechtTranslateOverrider'];
+ $translateDefaultInterpolation.$inject = ['$interpolate', '$translateSanitization'];
+ translateDirective.$inject = ['$translate', '$interpolate', '$compile', '$parse', '$rootScope'];
+ translateAttrDirective.$inject = ['$translate', '$rootScope'];
+ translateCloakDirective.$inject = ['$translate', '$rootScope'];
+ translateFilterFactory.$inject = ['$parse', '$translate'];
+ $translationCache.$inject = ['$cacheFactory'];
+ angular.module('pascalprecht.translate', ['ng']).run(runTranslate);
+
+ function runTranslate($translate) {
+
+ 'use strict';
+
+ var key = $translate.storageKey(),
+ storage = $translate.storage();
+
+ var fallbackFromIncorrectStorageValue = function fallbackFromIncorrectStorageValue() {
+ var preferred = $translate.preferredLanguage();
+ if (angular.isString(preferred)) {
+ $translate.use(preferred);
+ // $translate.use() will also remember the language.
+ // So, we don't need to call storage.put() here.
+ } else {
+ storage.put(key, $translate.use());
}
};
- if ($injector.has('$sanitize')) {
- $sanitize = $injector.get('$sanitize');
- }
- if ($injector.has('$sce')) {
- $sce = $injector.get('$sce');
+ fallbackFromIncorrectStorageValue.displayName = 'fallbackFromIncorrectStorageValue';
+
+ if (storage) {
+ if (!storage.get(key)) {
+ fallbackFromIncorrectStorageValue();
+ } else {
+ $translate.use(storage.get(key))['catch'](fallbackFromIncorrectStorageValue);
+ }
+ } else if (angular.isString($translate.preferredLanguage())) {
+ $translate.use($translate.preferredLanguage());
}
+ }
- return {
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateSanitization#useStrategy
- * @methodOf pascalprecht.translate.$translateSanitization
- *
- * @description
- * Selects a sanitization strategy. When an array is provided the strategies will be executed in order.
- *
- * @param {string|StrategyFunction|array} strategy The sanitization strategy / strategies which should be used. Either a name of an existing strategy, a custom strategy function, or an array consisting of multiple names and / or custom functions.
- */
- useStrategy: (function (self) {
- return function (strategy) {
- self.useStrategy(strategy);
- };
- })(this),
+ runTranslate.displayName = 'runTranslate';
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateSanitization#sanitize
- * @methodOf pascalprecht.translate.$translateSanitization
- *
- * @description
- * Sanitizes a value.
- *
- * @param {string|object} value The value which should be sanitized.
- * @param {string} mode The current sanitization mode, either 'params' or 'text'.
- * @param {string|StrategyFunction|array} [strategy] Optional custom strategy which should be used instead of the currently selected strategy.
- * @param {string} [context] The context of this call: filter, service. Default is service
- * @returns {string|object} sanitized value
- */
- sanitize: function (value, mode, strategy, context) {
- if (!currentStrategy) {
- showNoStrategyConfiguredWarning();
- }
+ /**
+ * @ngdoc object
+ * @name pascalprecht.translate.$translateSanitizationProvider
+ *
+ * @description
+ *
+ * Configurations for $translateSanitization
+ */
+ angular.module('pascalprecht.translate').provider('$translateSanitization', $translateSanitizationProvider);
- if (!strategy && strategy !== null) {
- strategy = currentStrategy;
- }
+ function $translateSanitizationProvider() {
- if (!strategy) {
- return value;
- }
+ 'use strict';
- if (!context) {
- context = 'service';
- }
+ var $sanitize,
+ $sce,
+ currentStrategy = null,
+ // TODO change to either 'sanitize', 'escape' or ['sanitize', 'escapeParameters'] in 3.0.
+ hasConfiguredStrategy = false,
+ hasShownNoStrategyConfiguredWarning = false,
+ strategies;
+
+ /**
+ * Definition of a sanitization strategy function
+ * @callback StrategyFunction
+ * @param {string|object} value - value to be sanitized (either a string or an interpolated value map)
+ * @param {string} mode - either 'text' for a string (translation) or 'params' for the interpolated params
+ * @return {string|object}
+ */
+
+ /**
+ * @ngdoc property
+ * @name strategies
+ * @propertyOf pascalprecht.translate.$translateSanitizationProvider
+ *
+ * @description
+ * Following strategies are built-in:
+ *
+ * - sanitize
+ * - Sanitizes HTML in the translation text using $sanitize
+ * - escape
+ * - Escapes HTML in the translation
+ * - sanitizeParameters
+ * - Sanitizes HTML in the values of the interpolation parameters using $sanitize
+ * - escapeParameters
+ * - Escapes HTML in the values of the interpolation parameters
+ * - escaped
+ * - Support legacy strategy name 'escaped' for backwards compatibility (will be removed in 3.0)
+ *
+ *
+ */
- var selectedStrategies = angular.isArray(strategy) ? strategy : [strategy];
- return applyStrategies(value, mode, context, selectedStrategies);
+ strategies = {
+ sanitize: function sanitize(value, mode /*, context*/) {
+ if (mode === 'text') {
+ value = htmlSanitizeValue(value);
+ }
+ return value;
+ },
+ escape: function escape(value, mode /*, context*/) {
+ if (mode === 'text') {
+ value = htmlEscapeValue(value);
+ }
+ return value;
+ },
+ sanitizeParameters: function sanitizeParameters(value, mode /*, context*/) {
+ if (mode === 'params') {
+ value = mapInterpolationParameters(value, htmlSanitizeValue);
+ }
+ return value;
+ },
+ escapeParameters: function escapeParameters(value, mode /*, context*/) {
+ if (mode === 'params') {
+ value = mapInterpolationParameters(value, htmlEscapeValue);
+ }
+ return value;
+ },
+ sce: function sce(value, mode, context) {
+ if (mode === 'text') {
+ value = htmlTrustValue(value);
+ } else if (mode === 'params') {
+ if (context !== 'filter') {
+ // do html escape in filter context #1101
+ value = mapInterpolationParameters(value, htmlEscapeValue);
+ }
+ }
+ return value;
+ },
+ sceParameters: function sceParameters(value, mode /*, context*/) {
+ if (mode === 'params') {
+ value = mapInterpolationParameters(value, htmlTrustValue);
+ }
+ return value;
}
};
- }];
+ // Support legacy strategy name 'escaped' for backwards compatibility.
+ // TODO should be removed in 3.0
+ strategies.escaped = strategies.escapeParameters;
- var htmlEscapeValue = function (value) {
- var element = angular.element('
');
- element.text(value); // not chainable, see #1044
- return element.html();
- };
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateSanitizationProvider#addStrategy
+ * @methodOf pascalprecht.translate.$translateSanitizationProvider
+ *
+ * @description
+ * Adds a sanitization strategy to the list of known strategies.
+ *
+ * @param {string} strategyName - unique key for a strategy
+ * @param {StrategyFunction} strategyFunction - strategy function
+ * @returns {object} this
+ */
+ this.addStrategy = function (strategyName, strategyFunction) {
+ strategies[strategyName] = strategyFunction;
+ return this;
+ };
- var htmlSanitizeValue = function (value) {
- if (!$sanitize) {
- throw new Error('pascalprecht.translate.$translateSanitization: Error cannot find $sanitize service. Either include the ngSanitize module (https://docs.angularjs.org/api/ngSanitize) or use a sanitization strategy which does not depend on $sanitize, such as \'escape\'.');
- }
- return $sanitize(value);
- };
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateSanitizationProvider#removeStrategy
+ * @methodOf pascalprecht.translate.$translateSanitizationProvider
+ *
+ * @description
+ * Removes a sanitization strategy from the list of known strategies.
+ *
+ * @param {string} strategyName - unique key for a strategy
+ * @returns {object} this
+ */
+ this.removeStrategy = function (strategyName) {
+ delete strategies[strategyName];
+ return this;
+ };
- var htmlTrustValue = function (value) {
- if (!$sce) {
- throw new Error('pascalprecht.translate.$translateSanitization: Error cannot find $sce service.');
- }
- return $sce.trustAsHtml(value);
- };
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateSanitizationProvider#useStrategy
+ * @methodOf pascalprecht.translate.$translateSanitizationProvider
+ *
+ * @description
+ * Selects a sanitization strategy. When an array is provided the strategies will be executed in order.
+ *
+ * @param {string|StrategyFunction|array} strategy The sanitization strategy / strategies which should be used. Either a name of an existing strategy, a custom strategy function, or an array consisting of multiple names and / or custom functions.
+ * @returns {object} this
+ */
+ this.useStrategy = function (strategy) {
+ hasConfiguredStrategy = true;
+ currentStrategy = strategy;
+ return this;
+ };
- var mapInterpolationParameters = function (value, iteratee, stack) {
- if (angular.isDate(value)) {
- return value;
- } else if (angular.isObject(value)) {
- var result = angular.isArray(value) ? [] : {};
+ /**
+ * @ngdoc object
+ * @name pascalprecht.translate.$translateSanitization
+ * @requires $injector
+ * @requires $log
+ *
+ * @description
+ * Sanitizes interpolation parameters and translated texts.
+ *
+ */
+ this.$get = ['$injector', '$log', function ($injector, $log) {
+
+ var cachedStrategyMap = {};
+
+ var applyStrategies = function applyStrategies(value, mode, context, selectedStrategies) {
+ angular.forEach(selectedStrategies, function (selectedStrategy) {
+ if (angular.isFunction(selectedStrategy)) {
+ value = selectedStrategy(value, mode, context);
+ } else if (angular.isFunction(strategies[selectedStrategy])) {
+ value = strategies[selectedStrategy](value, mode, context);
+ } else if (angular.isString(strategies[selectedStrategy])) {
+ if (!cachedStrategyMap[strategies[selectedStrategy]]) {
+ try {
+ cachedStrategyMap[strategies[selectedStrategy]] = $injector.get(strategies[selectedStrategy]);
+ } catch (e) {
+ cachedStrategyMap[strategies[selectedStrategy]] = function () {};
+ throw new Error('pascalprecht.translate.$translateSanitization: Unknown sanitization strategy: \'' + selectedStrategy + '\'');
+ }
+ }
+ value = cachedStrategyMap[strategies[selectedStrategy]](value, mode, context);
+ } else {
+ throw new Error('pascalprecht.translate.$translateSanitization: Unknown sanitization strategy: \'' + selectedStrategy + '\'');
+ }
+ });
+ return value;
+ };
- if (!stack) {
- stack = [];
- } else {
- if (stack.indexOf(value) > -1) {
- throw new Error('pascalprecht.translate.$translateSanitization: Error cannot interpolate parameter due recursive object');
+ // TODO: should be removed in 3.0
+ var showNoStrategyConfiguredWarning = function showNoStrategyConfiguredWarning() {
+ if (!hasConfiguredStrategy && !hasShownNoStrategyConfiguredWarning) {
+ $log.warn('pascalprecht.translate.$translateSanitization: No sanitization strategy has been configured. This can have serious security implications. See http://angular-translate.github.io/docs/#/guide/19_security for details.');
+ hasShownNoStrategyConfiguredWarning = true;
}
+ };
+
+ if ($injector.has('$sanitize')) {
+ $sanitize = $injector.get('$sanitize');
}
+ if ($injector.has('$sce')) {
+ $sce = $injector.get('$sce');
+ }
+
+ return {
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateSanitization#useStrategy
+ * @methodOf pascalprecht.translate.$translateSanitization
+ *
+ * @description
+ * Selects a sanitization strategy. When an array is provided the strategies will be executed in order.
+ *
+ * @param {string|StrategyFunction|array} strategy The sanitization strategy / strategies which should be used. Either a name of an existing strategy, a custom strategy function, or an array consisting of multiple names and / or custom functions.
+ */
+ useStrategy: function (self) {
+ return function (strategy) {
+ self.useStrategy(strategy);
+ };
+ }(this),
- stack.push(value);
- angular.forEach(value, function (propertyValue, propertyKey) {
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateSanitization#sanitize
+ * @methodOf pascalprecht.translate.$translateSanitization
+ *
+ * @description
+ * Sanitizes a value.
+ *
+ * @param {string|object} value The value which should be sanitized.
+ * @param {string} mode The current sanitization mode, either 'params' or 'text'.
+ * @param {string|StrategyFunction|array} [strategy] Optional custom strategy which should be used instead of the currently selected strategy.
+ * @param {string} [context] The context of this call: filter, service. Default is service
+ * @returns {string|object} sanitized value
+ */
+ sanitize: function sanitize(value, mode, strategy, context) {
+ if (!currentStrategy) {
+ showNoStrategyConfiguredWarning();
+ }
- /* Skipping function properties. */
- if (angular.isFunction(propertyValue)) {
- return;
+ if (!strategy && strategy !== null) {
+ strategy = currentStrategy;
+ }
+
+ if (!strategy) {
+ return value;
+ }
+
+ if (!context) {
+ context = 'service';
+ }
+
+ var selectedStrategies = angular.isArray(strategy) ? strategy : [strategy];
+ return applyStrategies(value, mode, context, selectedStrategies);
}
+ };
+ }];
- result[propertyKey] = mapInterpolationParameters(propertyValue, iteratee, stack);
- });
- stack.splice(-1, 1); // remove last
+ var htmlEscapeValue = function htmlEscapeValue(value) {
+ var element = angular.element('
');
+ element.text(value); // not chainable, see #1044
+ return element.html();
+ };
- return result;
- } else if (angular.isNumber(value)) {
- return value;
- } else if (!angular.isUndefined(value) && value !== null) {
- return iteratee(value);
- } else {
- return value;
- }
- };
-}
+ var htmlSanitizeValue = function htmlSanitizeValue(value) {
+ if (!$sanitize) {
+ throw new Error('pascalprecht.translate.$translateSanitization: Error cannot find $sanitize service. Either include the ngSanitize module (https://docs.angularjs.org/api/ngSanitize) or use a sanitization strategy which does not depend on $sanitize, such as \'escape\'.');
+ }
+ return $sanitize(value);
+ };
-/**
- * @ngdoc object
- * @name pascalprecht.translate.$translateProvider
- * @description
- *
- * $translateProvider allows developers to register translation-tables, asynchronous loaders
- * and similar to configure translation behavior directly inside of a module.
- *
- */
-angular.module('pascalprecht.translate')
- .constant('pascalprechtTranslateOverrider', {})
- .provider('$translate', $translate);
+ var htmlTrustValue = function htmlTrustValue(value) {
+ if (!$sce) {
+ throw new Error('pascalprecht.translate.$translateSanitization: Error cannot find $sce service.');
+ }
+ return $sce.trustAsHtml(value);
+ };
-function $translate($STORAGE_KEY, $windowProvider, $translateSanitizationProvider, pascalprechtTranslateOverrider) {
+ var mapInterpolationParameters = function mapInterpolationParameters(value, iteratee, stack) {
+ if (angular.isDate(value)) {
+ return value;
+ } else if (angular.isObject(value)) {
+ var result = angular.isArray(value) ? [] : {};
- 'use strict';
+ if (!stack) {
+ stack = [];
+ } else {
+ if (stack.indexOf(value) > -1) {
+ throw new Error('pascalprecht.translate.$translateSanitization: Error cannot interpolate parameter due recursive object');
+ }
+ }
+
+ stack.push(value);
+ angular.forEach(value, function (propertyValue, propertyKey) {
+
+ /* Skipping function properties. */
+ if (angular.isFunction(propertyValue)) {
+ return;
+ }
+
+ result[propertyKey] = mapInterpolationParameters(propertyValue, iteratee, stack);
+ });
+ stack.splice(-1, 1); // remove last
+
+ return result;
+ } else if (angular.isNumber(value)) {
+ return value;
+ } else if (!angular.isUndefined(value) && value !== null) {
+ return iteratee(value);
+ } else {
+ return value;
+ }
+ };
+ }
- var $translationTable = {},
- $preferredLanguage,
- $availableLanguageKeys = [],
- $languageKeyAliases,
- $fallbackLanguage,
- $fallbackWasString,
- $uses,
- $nextLang,
- $storageFactory,
- $storageKey = $STORAGE_KEY,
- $storagePrefix,
- $missingTranslationHandlerFactory,
- $interpolationFactory,
- $interpolatorFactories = [],
- $loaderFactory,
- $cloakClassName = 'translate-cloak',
- $loaderOptions,
- $notFoundIndicatorLeft,
- $notFoundIndicatorRight,
- $postCompilingEnabled = false,
- $forceAsyncReloadEnabled = false,
- $nestedObjectDelimeter = '.',
- $isReady = false,
- $keepContent = false,
- loaderCache,
- directivePriority = 0,
- statefulFilter = true,
- postProcessFn,
- uniformLanguageTagResolver = 'default',
- languageTagResolver = {
- 'default' : function (tag) {
+ /**
+ * @ngdoc object
+ * @name pascalprecht.translate.$translateProvider
+ * @description
+ *
+ * $translateProvider allows developers to register translation-tables, asynchronous loaders
+ * and similar to configure translation behavior directly inside of a module.
+ *
+ */
+ angular.module('pascalprecht.translate').constant('pascalprechtTranslateOverrider', {}).provider('$translate', $translate);
+
+ function $translate($STORAGE_KEY, $windowProvider, $translateSanitizationProvider, pascalprechtTranslateOverrider) {
+
+ 'use strict';
+
+ var $translationTable = {},
+ $preferredLanguage,
+ $availableLanguageKeys = [],
+ $languageKeyAliases,
+ $fallbackLanguage,
+ $fallbackWasString,
+ $uses,
+ $nextLang,
+ $storageFactory,
+ $storageKey = $STORAGE_KEY,
+ $storagePrefix,
+ $missingTranslationHandlerFactory,
+ $interpolationFactory,
+ $interpolatorFactories = [],
+ $loaderFactory,
+ $cloakClassName = 'translate-cloak',
+ $loaderOptions,
+ $notFoundIndicatorLeft,
+ $notFoundIndicatorRight,
+ $postCompilingEnabled = false,
+ $forceAsyncReloadEnabled = false,
+ $nestedObjectDelimeter = '.',
+ $isReady = false,
+ $keepContent = false,
+ loaderCache,
+ directivePriority = 0,
+ statefulFilter = true,
+ postProcessFn,
+ uniformLanguageTagResolver = 'default',
+ languageTagResolver = {
+ 'default': function _default(tag) {
return (tag || '').split('-').join('_');
},
- java : function (tag) {
+ java: function java(tag) {
var temp = (tag || '').split('-').join('_');
var parts = temp.split('_');
- return parts.length > 1 ? (parts[0].toLowerCase() + '_' + parts[1].toUpperCase()) : temp;
+ return parts.length > 1 ? parts[0].toLowerCase() + '_' + parts[1].toUpperCase() : temp;
},
- bcp47 : function (tag) {
+ bcp47: function bcp47(tag) {
var temp = (tag || '').split('_').join('-');
var parts = temp.split('-');
- return parts.length > 1 ? (parts[0].toLowerCase() + '-' + parts[1].toUpperCase()) : temp;
+ return parts.length > 1 ? parts[0].toLowerCase() + '-' + parts[1].toUpperCase() : temp;
},
- 'iso639-1' : function (tag) {
+ 'iso639-1': function iso6391(tag) {
var temp = (tag || '').split('_').join('-');
var parts = temp.split('-');
return parts[0].toLowerCase();
}
};
- var version = '2.15.1';
+ var version = '2.15.1';
- // tries to determine the browsers language
- var getFirstBrowserLanguage = function () {
+ // tries to determine the browsers language
+ var getFirstBrowserLanguage = function getFirstBrowserLanguage() {
- // internal purpose only
- if (angular.isFunction(pascalprechtTranslateOverrider.getLocale)) {
- return pascalprechtTranslateOverrider.getLocale();
- }
+ // internal purpose only
+ if (angular.isFunction(pascalprechtTranslateOverrider.getLocale)) {
+ return pascalprechtTranslateOverrider.getLocale();
+ }
- var nav = $windowProvider.$get().navigator,
- browserLanguagePropertyKeys = ['language', 'browserLanguage', 'systemLanguage', 'userLanguage'],
- i,
- language;
+ var nav = $windowProvider.$get().navigator,
+ browserLanguagePropertyKeys = ['language', 'browserLanguage', 'systemLanguage', 'userLanguage'],
+ i,
+ language;
- // support for HTML 5.1 "navigator.languages"
- if (angular.isArray(nav.languages)) {
- for (i = 0; i < nav.languages.length; i++) {
- language = nav.languages[i];
- if (language && language.length) {
- return language;
+ // support for HTML 5.1 "navigator.languages"
+ if (angular.isArray(nav.languages)) {
+ for (i = 0; i < nav.languages.length; i++) {
+ language = nav.languages[i];
+ if (language && language.length) {
+ return language;
+ }
}
}
- }
- // support for other well known properties in browsers
- for (i = 0; i < browserLanguagePropertyKeys.length; i++) {
- language = nav[browserLanguagePropertyKeys[i]];
- if (language && language.length) {
- return language;
+ // support for other well known properties in browsers
+ for (i = 0; i < browserLanguagePropertyKeys.length; i++) {
+ language = nav[browserLanguagePropertyKeys[i]];
+ if (language && language.length) {
+ return language;
+ }
}
- }
- return null;
- };
- getFirstBrowserLanguage.displayName = 'angular-translate/service: getFirstBrowserLanguage';
+ return null;
+ };
+ getFirstBrowserLanguage.displayName = 'angular-translate/service: getFirstBrowserLanguage';
- // tries to determine the browsers locale
- var getLocale = function () {
- var locale = getFirstBrowserLanguage() || '';
- if (languageTagResolver[uniformLanguageTagResolver]) {
- locale = languageTagResolver[uniformLanguageTagResolver](locale);
- }
- return locale;
- };
- getLocale.displayName = 'angular-translate/service: getLocale';
+ // tries to determine the browsers locale
+ var getLocale = function getLocale() {
+ var locale = getFirstBrowserLanguage() || '';
+ if (languageTagResolver[uniformLanguageTagResolver]) {
+ locale = languageTagResolver[uniformLanguageTagResolver](locale);
+ }
+ return locale;
+ };
+ getLocale.displayName = 'angular-translate/service: getLocale';
- /**
- * @name indexOf
- * @private
- *
- * @description
- * indexOf polyfill. Kinda sorta.
- *
- * @param {array} array Array to search in.
- * @param {string} searchElement Element to search for.
- *
- * @returns {int} Index of search element.
- */
- var indexOf = function (array, searchElement) {
- for (var i = 0, len = array.length; i < len; i++) {
- if (array[i] === searchElement) {
- return i;
+ /**
+ * @name indexOf
+ * @private
+ *
+ * @description
+ * indexOf polyfill. Kinda sorta.
+ *
+ * @param {array} array Array to search in.
+ * @param {string} searchElement Element to search for.
+ *
+ * @returns {int} Index of search element.
+ */
+ var indexOf = function indexOf(array, searchElement) {
+ for (var i = 0, len = array.length; i < len; i++) {
+ if (array[i] === searchElement) {
+ return i;
+ }
}
- }
- return -1;
- };
+ return -1;
+ };
- /**
- * @name trim
- * @private
- *
- * @description
- * trim polyfill
- *
- * @returns {string} The string stripped of whitespace from both ends
- */
- var trim = function () {
- return this.toString().replace(/^\s+|\s+$/g, '');
- };
+ /**
+ * @name trim
+ * @private
+ *
+ * @description
+ * trim polyfill
+ *
+ * @returns {string} The string stripped of whitespace from both ends
+ */
+ var trim = function trim() {
+ return this.toString().replace(/^\s+|\s+$/g, '');
+ };
- var negotiateLocale = function (preferred) {
- if (!preferred) {
- return;
- }
+ var negotiateLocale = function negotiateLocale(preferred) {
+ if (!preferred) {
+ return;
+ }
- var avail = [],
- locale = angular.lowercase(preferred),
- i = 0,
- n = $availableLanguageKeys.length;
+ var avail = [],
+ locale = angular.lowercase(preferred),
+ i = 0,
+ n = $availableLanguageKeys.length;
- for (; i < n; i++) {
- avail.push(angular.lowercase($availableLanguageKeys[i]));
- }
+ for (; i < n; i++) {
+ avail.push(angular.lowercase($availableLanguageKeys[i]));
+ }
- // Check for an exact match in our list of available keys
- if (indexOf(avail, locale) > -1) {
- return preferred;
- }
+ // Check for an exact match in our list of available keys
+ if (indexOf(avail, locale) > -1) {
+ return preferred;
+ }
- if ($languageKeyAliases) {
- var alias;
- for (var langKeyAlias in $languageKeyAliases) {
- if ($languageKeyAliases.hasOwnProperty(langKeyAlias)) {
- var hasWildcardKey = false;
- var hasExactKey = Object.prototype.hasOwnProperty.call($languageKeyAliases, langKeyAlias) &&
- angular.lowercase(langKeyAlias) === angular.lowercase(preferred);
+ if ($languageKeyAliases) {
+ var alias;
+ for (var langKeyAlias in $languageKeyAliases) {
+ if ($languageKeyAliases.hasOwnProperty(langKeyAlias)) {
+ var hasWildcardKey = false;
+ var hasExactKey = Object.prototype.hasOwnProperty.call($languageKeyAliases, langKeyAlias) && angular.lowercase(langKeyAlias) === angular.lowercase(preferred);
- if (langKeyAlias.slice(-1) === '*') {
- hasWildcardKey = langKeyAlias.slice(0, -1) === preferred.slice(0, langKeyAlias.length - 1);
- }
- if (hasExactKey || hasWildcardKey) {
- alias = $languageKeyAliases[langKeyAlias];
- if (indexOf(avail, angular.lowercase(alias)) > -1) {
- return alias;
+ if (langKeyAlias.slice(-1) === '*') {
+ hasWildcardKey = langKeyAlias.slice(0, -1) === preferred.slice(0, langKeyAlias.length - 1);
+ }
+ if (hasExactKey || hasWildcardKey) {
+ alias = $languageKeyAliases[langKeyAlias];
+ if (indexOf(avail, angular.lowercase(alias)) > -1) {
+ return alias;
+ }
}
}
}
}
- }
- // Check for a language code without region
- var parts = preferred.split('_');
-
- if (parts.length > 1 && indexOf(avail, angular.lowercase(parts[0])) > -1) {
- return parts[0];
- }
+ // Check for a language code without region
+ var parts = preferred.split('_');
- // If everything fails, return undefined.
- return;
- };
+ if (parts.length > 1 && indexOf(avail, angular.lowercase(parts[0])) > -1) {
+ return parts[0];
+ }
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#translations
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Registers a new translation table for specific language key.
- *
- * To register a translation table for specific language, pass a defined language
- * key as first parameter.
- *
- *
- * // register translation table for language: 'de_DE'
- * $translateProvider.translations('de_DE', {
- * 'GREETING': 'Hallo Welt!'
- * });
- *
- * // register another one
- * $translateProvider.translations('en_US', {
- * 'GREETING': 'Hello world!'
- * });
- *
- *
- * When registering multiple translation tables for for the same language key,
- * the actual translation table gets extended. This allows you to define module
- * specific translation which only get added, once a specific module is loaded in
- * your app.
- *
- * Invoking this method with no arguments returns the translation table which was
- * registered with no language key. Invoking it with a language key returns the
- * related translation table.
- *
- * @param {string} langKey A language key.
- * @param {object} translationTable A plain old JavaScript object that represents a translation table.
- *
- */
- var translations = function (langKey, translationTable) {
+ // If everything fails, return undefined.
+ return;
+ };
- if (!langKey && !translationTable) {
- return $translationTable;
- }
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#translations
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ * Registers a new translation table for specific language key.
+ *
+ * To register a translation table for specific language, pass a defined language
+ * key as first parameter.
+ *
+ *
+ * // register translation table for language: 'de_DE'
+ * $translateProvider.translations('de_DE', {
+ * 'GREETING': 'Hallo Welt!'
+ * });
+ *
+ * // register another one
+ * $translateProvider.translations('en_US', {
+ * 'GREETING': 'Hello world!'
+ * });
+ *
+ *
+ * When registering multiple translation tables for for the same language key,
+ * the actual translation table gets extended. This allows you to define module
+ * specific translation which only get added, once a specific module is loaded in
+ * your app.
+ *
+ * Invoking this method with no arguments returns the translation table which was
+ * registered with no language key. Invoking it with a language key returns the
+ * related translation table.
+ *
+ * @param {string} langKey A language key.
+ * @param {object} translationTable A plain old JavaScript object that represents a translation table.
+ *
+ */
+ var translations = function translations(langKey, translationTable) {
- if (langKey && !translationTable) {
- if (angular.isString(langKey)) {
- return $translationTable[langKey];
+ if (!langKey && !translationTable) {
+ return $translationTable;
}
- } else {
- if (!angular.isObject($translationTable[langKey])) {
- $translationTable[langKey] = {};
+
+ if (langKey && !translationTable) {
+ if (angular.isString(langKey)) {
+ return $translationTable[langKey];
+ }
+ } else {
+ if (!angular.isObject($translationTable[langKey])) {
+ $translationTable[langKey] = {};
+ }
+ angular.extend($translationTable[langKey], flatObject(translationTable));
}
- angular.extend($translationTable[langKey], flatObject(translationTable));
- }
- return this;
- };
+ return this;
+ };
- this.translations = translations;
+ this.translations = translations;
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#cloakClassName
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- *
- * Let's you change the class name for `translate-cloak` directive.
- * Default class name is `translate-cloak`.
- *
- * @param {string} name translate-cloak class name
- */
- this.cloakClassName = function (name) {
- if (!name) {
- return $cloakClassName;
- }
- $cloakClassName = name;
- return this;
- };
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#cloakClassName
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ *
+ * Let's you change the class name for `translate-cloak` directive.
+ * Default class name is `translate-cloak`.
+ *
+ * @param {string} name translate-cloak class name
+ */
+ this.cloakClassName = function (name) {
+ if (!name) {
+ return $cloakClassName;
+ }
+ $cloakClassName = name;
+ return this;
+ };
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#nestedObjectDelimeter
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- *
- * Let's you change the delimiter for namespaced translations.
- * Default delimiter is `.`.
- *
- * @param {string} delimiter namespace separator
- */
- this.nestedObjectDelimeter = function (delimiter) {
- if (!delimiter) {
- return $nestedObjectDelimeter;
- }
- $nestedObjectDelimeter = delimiter;
- return this;
- };
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#nestedObjectDelimeter
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ *
+ * Let's you change the delimiter for namespaced translations.
+ * Default delimiter is `.`.
+ *
+ * @param {string} delimiter namespace separator
+ */
+ this.nestedObjectDelimeter = function (delimiter) {
+ if (!delimiter) {
+ return $nestedObjectDelimeter;
+ }
+ $nestedObjectDelimeter = delimiter;
+ return this;
+ };
- /**
- * @name flatObject
- * @private
- *
- * @description
- * Flats an object. This function is used to flatten given translation data with
- * namespaces, so they are later accessible via dot notation.
- */
- var flatObject = function (data, path, result, prevKey) {
- var key, keyWithPath, keyWithShortPath, val;
+ /**
+ * @name flatObject
+ * @private
+ *
+ * @description
+ * Flats an object. This function is used to flatten given translation data with
+ * namespaces, so they are later accessible via dot notation.
+ */
+ var flatObject = function flatObject(data, path, result, prevKey) {
+ var key, keyWithPath, keyWithShortPath, val;
- if (!path) {
- path = [];
- }
- if (!result) {
- result = {};
- }
- for (key in data) {
- if (!Object.prototype.hasOwnProperty.call(data, key)) {
- continue;
+ if (!path) {
+ path = [];
}
- val = data[key];
- if (angular.isObject(val)) {
- flatObject(val, path.concat(key), result, key);
- } else {
- keyWithPath = path.length ? ('' + path.join($nestedObjectDelimeter) + $nestedObjectDelimeter + key) : key;
- if (path.length && key === prevKey) {
- // Create shortcut path (foo.bar == foo.bar.bar)
- keyWithShortPath = '' + path.join($nestedObjectDelimeter);
- // Link it to original path
- result[keyWithShortPath] = '@:' + keyWithPath;
- }
- result[keyWithPath] = val;
+ if (!result) {
+ result = {};
}
- }
- return result;
- };
- flatObject.displayName = 'flatObject';
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#addInterpolation
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Adds interpolation services to angular-translate, so it can manage them.
- *
- * @param {object} factory Interpolation service factory
- */
- this.addInterpolation = function (factory) {
- $interpolatorFactories.push(factory);
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useMessageFormatInterpolation
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use interpolation functionality of messageformat.js.
- * This is useful when having high level pluralization and gender selection.
- */
- this.useMessageFormatInterpolation = function () {
- return this.useInterpolation('$translateMessageFormatInterpolation');
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useInterpolation
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate which interpolation style to use as default, application-wide.
- * Simply pass a factory/service name. The interpolation service has to implement
- * the correct interface.
- *
- * @param {string} factory Interpolation service name.
- */
- this.useInterpolation = function (factory) {
- $interpolationFactory = factory;
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useSanitizeStrategy
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Simply sets a sanitation strategy type.
- *
- * @param {string} value Strategy type.
- */
- this.useSanitizeValueStrategy = function (value) {
- $translateSanitizationProvider.useStrategy(value);
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#preferredLanguage
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells the module which of the registered translation tables to use for translation
- * at initial startup by passing a language key. Similar to `$translateProvider#use`
- * only that it says which language to **prefer**.
- *
- * @param {string} langKey A language key.
- */
- this.preferredLanguage = function (langKey) {
- if (langKey) {
- setupPreferredLanguage(langKey);
- return this;
- }
- return $preferredLanguage;
- };
- var setupPreferredLanguage = function (langKey) {
- if (langKey) {
- $preferredLanguage = langKey;
- }
- return $preferredLanguage;
- };
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicator
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Sets an indicator which is used when a translation isn't found. E.g. when
- * setting the indicator as 'X' and one tries to translate a translation id
- * called `NOT_FOUND`, this will result in `X NOT_FOUND X`.
- *
- * Internally this methods sets a left indicator and a right indicator using
- * `$translateProvider.translationNotFoundIndicatorLeft()` and
- * `$translateProvider.translationNotFoundIndicatorRight()`.
- *
- * **Note**: These methods automatically add a whitespace between the indicators
- * and the translation id.
- *
- * @param {string} indicator An indicator, could be any string.
- */
- this.translationNotFoundIndicator = function (indicator) {
- this.translationNotFoundIndicatorLeft(indicator);
- this.translationNotFoundIndicatorRight(indicator);
- return this;
- };
-
- /**
- * ngdoc function
- * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicatorLeft
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Sets an indicator which is used when a translation isn't found left to the
- * translation id.
- *
- * @param {string} indicator An indicator.
- */
- this.translationNotFoundIndicatorLeft = function (indicator) {
- if (!indicator) {
- return $notFoundIndicatorLeft;
- }
- $notFoundIndicatorLeft = indicator;
- return this;
- };
-
- /**
- * ngdoc function
- * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicatorLeft
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Sets an indicator which is used when a translation isn't found right to the
- * translation id.
- *
- * @param {string} indicator An indicator.
- */
- this.translationNotFoundIndicatorRight = function (indicator) {
- if (!indicator) {
- return $notFoundIndicatorRight;
- }
- $notFoundIndicatorRight = indicator;
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#fallbackLanguage
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells the module which of the registered translation tables to use when missing translations
- * at initial startup by passing a language key. Similar to `$translateProvider#use`
- * only that it says which language to **fallback**.
- *
- * @param {string||array} langKey A language key.
- *
- */
- this.fallbackLanguage = function (langKey) {
- fallbackStack(langKey);
- return this;
- };
-
- var fallbackStack = function (langKey) {
- if (langKey) {
- if (angular.isString(langKey)) {
- $fallbackWasString = true;
- $fallbackLanguage = [langKey];
- } else if (angular.isArray(langKey)) {
- $fallbackWasString = false;
- $fallbackLanguage = langKey;
- }
- if (angular.isString($preferredLanguage) && indexOf($fallbackLanguage, $preferredLanguage) < 0) {
- $fallbackLanguage.push($preferredLanguage);
- }
-
- return this;
- } else {
- if ($fallbackWasString) {
- return $fallbackLanguage[0];
- } else {
- return $fallbackLanguage;
- }
- }
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#use
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Set which translation table to use for translation by given language key. When
- * trying to 'use' a language which isn't provided, it'll throw an error.
- *
- * You actually don't have to use this method since `$translateProvider#preferredLanguage`
- * does the job too.
- *
- * @param {string} langKey A language key.
- */
- this.use = function (langKey) {
- if (langKey) {
- if (!$translationTable[langKey] && (!$loaderFactory)) {
- // only throw an error, when not loading translation data asynchronously
- throw new Error('$translateProvider couldn\'t find translationTable for langKey: \'' + langKey + '\'');
- }
- $uses = langKey;
- return this;
- }
- return $uses;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#resolveClientLocale
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * This returns the current browser/client's language key. The result is processed with the configured uniform tag resolver.
- *
- * @returns {string} the current client/browser language key
- */
- this.resolveClientLocale = function () {
- return getLocale();
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#storageKey
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells the module which key must represent the choosed language by a user in the storage.
- *
- * @param {string} key A key for the storage.
- */
- var storageKey = function (key) {
- if (!key) {
- if ($storagePrefix) {
- return $storagePrefix + $storageKey;
+ for (key in data) {
+ if (!Object.prototype.hasOwnProperty.call(data, key)) {
+ continue;
+ }
+ val = data[key];
+ if (angular.isObject(val)) {
+ flatObject(val, path.concat(key), result, key);
+ } else {
+ keyWithPath = path.length ? '' + path.join($nestedObjectDelimeter) + $nestedObjectDelimeter + key : key;
+ if (path.length && key === prevKey) {
+ // Create shortcut path (foo.bar == foo.bar.bar)
+ keyWithShortPath = '' + path.join($nestedObjectDelimeter);
+ // Link it to original path
+ result[keyWithShortPath] = '@:' + keyWithPath;
+ }
+ result[keyWithPath] = val;
+ }
}
- return $storageKey;
- }
- $storageKey = key;
- return this;
- };
-
- this.storageKey = storageKey;
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useUrlLoader
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use `$translateUrlLoader` extension service as loader.
- *
- * @param {string} url Url
- * @param {Object=} options Optional configuration object
- */
- this.useUrlLoader = function (url, options) {
- return this.useLoader('$translateUrlLoader', angular.extend({url : url}, options));
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useStaticFilesLoader
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use `$translateStaticFilesLoader` extension service as loader.
- *
- * @param {Object=} options Optional configuration object
- */
- this.useStaticFilesLoader = function (options) {
- return this.useLoader('$translateStaticFilesLoader', options);
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useLoader
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use any other service as loader.
- *
- * @param {string} loaderFactory Factory name to use
- * @param {Object=} options Optional configuration object
- */
- this.useLoader = function (loaderFactory, options) {
- $loaderFactory = loaderFactory;
- $loaderOptions = options || {};
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useLocalStorage
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use `$translateLocalStorage` service as storage layer.
- *
- */
- this.useLocalStorage = function () {
- return this.useStorage('$translateLocalStorage');
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useCookieStorage
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use `$translateCookieStorage` service as storage layer.
- */
- this.useCookieStorage = function () {
- return this.useStorage('$translateCookieStorage');
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useStorage
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use custom service as storage layer.
- */
- this.useStorage = function (storageFactory) {
- $storageFactory = storageFactory;
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#storagePrefix
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Sets prefix for storage key.
- *
- * @param {string} prefix Storage key prefix
- */
- this.storagePrefix = function (prefix) {
- if (!prefix) {
- return prefix;
- }
- $storagePrefix = prefix;
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useMissingTranslationHandlerLog
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to use built-in log handler when trying to translate
- * a translation Id which doesn't exist.
- *
- * This is actually a shortcut method for `useMissingTranslationHandler()`.
- *
- */
- this.useMissingTranslationHandlerLog = function () {
- return this.useMissingTranslationHandler('$translateMissingTranslationHandlerLog');
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useMissingTranslationHandler
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Expects a factory name which later gets instantiated with `$injector`.
- * This method can be used to tell angular-translate to use a custom
- * missingTranslationHandler. Just build a factory which returns a function
- * and expects a translation id as argument.
- *
- * Example:
- *
- * app.config(function ($translateProvider) {
- * $translateProvider.useMissingTranslationHandler('customHandler');
- * });
- *
- * app.factory('customHandler', function (dep1, dep2) {
- * return function (translationId) {
- * // something with translationId and dep1 and dep2
- * };
- * });
- *
- *
- * @param {string} factory Factory name
- */
- this.useMissingTranslationHandler = function (factory) {
- $missingTranslationHandlerFactory = factory;
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#usePostCompiling
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * If post compiling is enabled, all translated values will be processed
- * again with AngularJS' $compile.
- *
- * Example:
- *
- * app.config(function ($translateProvider) {
- * $translateProvider.usePostCompiling(true);
- * });
- *
- *
- * @param {string} factory Factory name
- */
- this.usePostCompiling = function (value) {
- $postCompilingEnabled = !(!value);
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#forceAsyncReload
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * If force async reload is enabled, async loader will always be called
- * even if $translationTable already contains the language key, adding
- * possible new entries to the $translationTable.
- *
- * Example:
- *
- * app.config(function ($translateProvider) {
- * $translateProvider.forceAsyncReload(true);
- * });
- *
- *
- * @param {boolean} value - valid values are true or false
- */
- this.forceAsyncReload = function (value) {
- $forceAsyncReloadEnabled = !(!value);
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#uniformLanguageTag
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate which language tag should be used as a result when determining
- * the current browser language.
- *
- * This setting must be set before invoking {@link pascalprecht.translate.$translateProvider#methods_determinePreferredLanguage determinePreferredLanguage()}.
- *
- *
- * $translateProvider
- * .uniformLanguageTag('bcp47')
- * .determinePreferredLanguage()
- *
- *
- * The resolver currently supports:
- * * default
- * (traditionally: hyphens will be converted into underscores, i.e. en-US => en_US)
- * en-US => en_US
- * en_US => en_US
- * en-us => en_us
- * * java
- * like default, but the second part will be always in uppercase
- * en-US => en_US
- * en_US => en_US
- * en-us => en_US
- * * BCP 47 (RFC 4646 & 4647)
- * en-US => en-US
- * en_US => en-US
- * en-us => en-US
- *
- * See also:
- * * http://en.wikipedia.org/wiki/IETF_language_tag
- * * http://www.w3.org/International/core/langtags/
- * * http://tools.ietf.org/html/bcp47
- *
- * @param {string|object} options - options (or standard)
- * @param {string} options.standard - valid values are 'default', 'bcp47', 'java'
- */
- this.uniformLanguageTag = function (options) {
-
- if (!options) {
- options = {};
- } else if (angular.isString(options)) {
- options = {
- standard : options
- };
- }
-
- uniformLanguageTagResolver = options.standard;
-
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#determinePreferredLanguage
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Tells angular-translate to try to determine on its own which language key
- * to set as preferred language. When `fn` is given, angular-translate uses it
- * to determine a language key, otherwise it uses the built-in `getLocale()`
- * method.
- *
- * The `getLocale()` returns a language key in the format `[lang]_[country]` or
- * `[lang]` depending on what the browser provides.
- *
- * Use this method at your own risk, since not all browsers return a valid
- * locale (see {@link pascalprecht.translate.$translateProvider#methods_uniformLanguageTag uniformLanguageTag()}).
- *
- * @param {Function=} fn Function to determine a browser's locale
- */
- this.determinePreferredLanguage = function (fn) {
-
- var locale = (fn && angular.isFunction(fn)) ? fn() : getLocale();
-
- if (!$availableLanguageKeys.length) {
- $preferredLanguage = locale;
- } else {
- $preferredLanguage = negotiateLocale(locale) || locale;
- }
-
- return this;
- };
+ return result;
+ };
+ flatObject.displayName = 'flatObject';
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#registerAvailableLanguageKeys
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Registers a set of language keys the app will work with. Use this method in
- * combination with
- * {@link pascalprecht.translate.$translateProvider#determinePreferredLanguage determinePreferredLanguage}.
- * When available languages keys are registered, angular-translate
- * tries to find the best fitting language key depending on the browsers locale,
- * considering your language key convention.
- *
- * @param {object} languageKeys Array of language keys the your app will use
- * @param {object=} aliases Alias map.
- */
- this.registerAvailableLanguageKeys = function (languageKeys, aliases) {
- if (languageKeys) {
- $availableLanguageKeys = languageKeys;
- if (aliases) {
- $languageKeyAliases = aliases;
- }
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#addInterpolation
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ * Adds interpolation services to angular-translate, so it can manage them.
+ *
+ * @param {object} factory Interpolation service factory
+ */
+ this.addInterpolation = function (factory) {
+ $interpolatorFactories.push(factory);
return this;
- }
- return $availableLanguageKeys;
- };
+ };
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#useLoaderCache
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Registers a cache for internal $http based loaders.
- * {@link pascalprecht.translate.$translationCache $translationCache}.
- * When false the cache will be disabled (default). When true or undefined
- * the cache will be a default (see $cacheFactory). When an object it will
- * be treat as a cache object itself: the usage is $http({cache: cache})
- *
- * @param {object} cache boolean, string or cache-object
- */
- this.useLoaderCache = function (cache) {
- if (cache === false) {
- // disable cache
- loaderCache = undefined;
- } else if (cache === true) {
- // enable cache using AJS defaults
- loaderCache = true;
- } else if (typeof(cache) === 'undefined') {
- // enable cache using default
- loaderCache = '$translationCache';
- } else if (cache) {
- // enable cache using given one (see $cacheFactory)
- loaderCache = cache;
- }
- return this;
- };
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#useMessageFormatInterpolation
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ * Tells angular-translate to use interpolation functionality of messageformat.js.
+ * This is useful when having high level pluralization and gender selection.
+ */
+ this.useMessageFormatInterpolation = function () {
+ return this.useInterpolation('$translateMessageFormatInterpolation');
+ };
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#directivePriority
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Sets the default priority of the translate directive. The standard value is `0`.
- * Calling this function without an argument will return the current value.
- *
- * @param {number} priority for the translate-directive
- */
- this.directivePriority = function (priority) {
- if (priority === undefined) {
- // getter
- return directivePriority;
- } else {
- // setter with chaining
- directivePriority = priority;
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#useInterpolation
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ * Tells angular-translate which interpolation style to use as default, application-wide.
+ * Simply pass a factory/service name. The interpolation service has to implement
+ * the correct interface.
+ *
+ * @param {string} factory Interpolation service name.
+ */
+ this.useInterpolation = function (factory) {
+ $interpolationFactory = factory;
return this;
- }
- };
+ };
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#statefulFilter
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * Since AngularJS 1.3, filters which are not stateless (depending at the scope)
- * have to explicit define this behavior.
- * Sets whether the translate filter should be stateful or stateless. The standard value is `true`
- * meaning being stateful.
- * Calling this function without an argument will return the current value.
- *
- * @param {boolean} state - defines the state of the filter
- */
- this.statefulFilter = function (state) {
- if (state === undefined) {
- // getter
- return statefulFilter;
- } else {
- // setter with chaining
- statefulFilter = state;
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#useSanitizeStrategy
+ * @methodOf pascalprecht.translate.$translateProvider
+ *
+ * @description
+ * Simply sets a sanitation strategy type.
+ *
+ * @param {string} value Strategy type.
+ */
+ this.useSanitizeValueStrategy = function (value) {
+ $translateSanitizationProvider.useStrategy(value);
return this;
- }
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#postProcess
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * The post processor will be intercept right after the translation result. It can modify the result.
- *
- * @param {object} fn Function or service name (string) to be called after the translation value has been set / resolved. The function itself will enrich every value being processed and then continue the normal resolver process
- */
- this.postProcess = function (fn) {
- if (fn) {
- postProcessFn = fn;
- } else {
- postProcessFn = undefined;
- }
- return this;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateProvider#keepContent
- * @methodOf pascalprecht.translate.$translateProvider
- *
- * @description
- * If keepContent is set to true than translate directive will always use innerHTML
- * as a default translation
- *
- * Example:
- *
- * app.config(function ($translateProvider) {
- * $translateProvider.keepContent(true);
- * });
- *
- *
- * @param {boolean} value - valid values are true or false
- */
- this.keepContent = function (value) {
- $keepContent = !(!value);
- return this;
- };
-
- /**
- * @ngdoc object
- * @name pascalprecht.translate.$translate
- * @requires $interpolate
- * @requires $log
- * @requires $rootScope
- * @requires $q
- *
- * @description
- * The `$translate` service is the actual core of angular-translate. It expects a translation id
- * and optional interpolate parameters to translate contents.
- *
- *
- * $translate('HEADLINE_TEXT').then(function (translation) {
- * $scope.translatedText = translation;
- * });
- *
- *
- * @param {string|array} translationId A token which represents a translation id
- * This can be optionally an array of translation ids which
- * results that the function returns an object where each key
- * is the translation id and the value the translation.
- * @param {object=} interpolateParams An object hash for dynamic values
- * @param {string} interpolationId The id of the interpolation to use
- * @param {string} defaultTranslationText the optional default translation text that is written as
- * as default text in case it is not found in any configured language
- * @param {string} forceLanguage A language to be used instead of the current language
- * @returns {object} promise
- */
- this.$get = ['$log', '$injector', '$rootScope', '$q', function ($log, $injector, $rootScope, $q) {
-
- var Storage,
- defaultInterpolator = $injector.get($interpolationFactory || '$translateDefaultInterpolation'),
- pendingLoader = false,
- interpolatorHashMap = {},
- langPromises = {},
- fallbackIndex,
- startFallbackIteration;
-
- var $translate = function (translationId, interpolateParams, interpolationId, defaultTranslationText, forceLanguage) {
- if (!$uses && $preferredLanguage) {
- $uses = $preferredLanguage;
- }
- var uses = (forceLanguage && forceLanguage !== $uses) ? // we don't want to re-negotiate $uses
- (negotiateLocale(forceLanguage) || forceLanguage) : $uses;
-
- // Check forceLanguage is present
- if (forceLanguage) {
- loadTranslationsIfMissing(forceLanguage);
- }
-
- // Duck detection: If the first argument is an array, a bunch of translations was requested.
- // The result is an object.
- if (angular.isArray(translationId)) {
- // Inspired by Q.allSettled by Kris Kowal
- // https://github.com/kriskowal/q/blob/b0fa72980717dc202ffc3cbf03b936e10ebbb9d7/q.js#L1553-1563
- // This transforms all promises regardless resolved or rejected
- var translateAll = function (translationIds) {
- var results = {}; // storing the actual results
- var promises = []; // promises to wait for
- // Wraps the promise a) being always resolved and b) storing the link id->value
- var translate = function (translationId) {
- var deferred = $q.defer();
- var regardless = function (value) {
- results[translationId] = value;
- deferred.resolve([translationId, value]);
- };
- // we don't care whether the promise was resolved or rejected; just store the values
- $translate(translationId, interpolateParams, interpolationId, defaultTranslationText, forceLanguage).then(regardless, regardless);
- return deferred.promise;
- };
- for (var i = 0, c = translationIds.length; i < c; i++) {
- promises.push(translate(translationIds[i]));
- }
- // wait for all (including storing to results)
- return $q.all(promises).then(function () {
- // return the results
- return results;
- });
- };
- return translateAll(translationId);
- }
-
- var deferred = $q.defer();
-
- // trim off any whitespace
- if (translationId) {
- translationId = trim.apply(translationId);
- }
-
- var promiseToWaitFor = (function () {
- var promise = $preferredLanguage ?
- langPromises[$preferredLanguage] :
- langPromises[uses];
-
- fallbackIndex = 0;
-
- if ($storageFactory && !promise) {
- // looks like there's no pending promise for $preferredLanguage or
- // $uses. Maybe there's one pending for a language that comes from
- // storage.
- var langKey = Storage.get($storageKey);
- promise = langPromises[langKey];
-
- if ($fallbackLanguage && $fallbackLanguage.length) {
- var index = indexOf($fallbackLanguage, langKey);
- // maybe the language from storage is also defined as fallback language
- // we increase the fallback language index to not search in that language
- // as fallback, since it's probably the first used language
- // in that case the index starts after the first element
- fallbackIndex = (index === 0) ? 1 : 0;
-
- // but we can make sure to ALWAYS fallback to preferred language at least
- if (indexOf($fallbackLanguage, $preferredLanguage) < 0) {
- $fallbackLanguage.push($preferredLanguage);
- }
- }
- }
- return promise;
- }());
-
- if (!promiseToWaitFor) {
- // no promise to wait for? okay. Then there's no loader registered
- // nor is a one pending for language that comes from storage.
- // We can just translate.
- determineTranslation(translationId, interpolateParams, interpolationId, defaultTranslationText, uses).then(deferred.resolve, deferred.reject);
- } else {
- var promiseResolved = function () {
- // $uses may have changed while waiting
- if (!forceLanguage) {
- uses = $uses;
- }
- determineTranslation(translationId, interpolateParams, interpolationId, defaultTranslationText, uses).then(deferred.resolve, deferred.reject);
- };
- promiseResolved.displayName = 'promiseResolved';
-
- promiseToWaitFor['finally'](promiseResolved)
- .catch(angular.noop); // we don't care about errors here, already handled
- }
- return deferred.promise;
};
/**
- * @name applyNotFoundIndicators
- * @private
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#preferredLanguage
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Applies not fount indicators to given translation id, if needed.
- * This function gets only executed, if a translation id doesn't exist,
- * which is why a translation id is expected as argument.
+ * Tells the module which of the registered translation tables to use for translation
+ * at initial startup by passing a language key. Similar to `$translateProvider#use`
+ * only that it says which language to **prefer**.
*
- * @param {string} translationId Translation id.
- * @returns {string} Same as given translation id but applied with not found
- * indicators.
+ * @param {string} langKey A language key.
*/
- var applyNotFoundIndicators = function (translationId) {
- // applying notFoundIndicators
- if ($notFoundIndicatorLeft) {
- translationId = [$notFoundIndicatorLeft, translationId].join(' ');
+ this.preferredLanguage = function (langKey) {
+ if (langKey) {
+ setupPreferredLanguage(langKey);
+ return this;
}
- if ($notFoundIndicatorRight) {
- translationId = [translationId, $notFoundIndicatorRight].join(' ');
+ return $preferredLanguage;
+ };
+ var setupPreferredLanguage = function setupPreferredLanguage(langKey) {
+ if (langKey) {
+ $preferredLanguage = langKey;
}
- return translationId;
+ return $preferredLanguage;
};
-
/**
- * @name useLanguage
- * @private
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicator
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Makes actual use of a language by setting a given language key as used
- * language and informs registered interpolators to also use the given
- * key as locale.
+ * Sets an indicator which is used when a translation isn't found. E.g. when
+ * setting the indicator as 'X' and one tries to translate a translation id
+ * called `NOT_FOUND`, this will result in `X NOT_FOUND X`.
+ *
+ * Internally this methods sets a left indicator and a right indicator using
+ * `$translateProvider.translationNotFoundIndicatorLeft()` and
+ * `$translateProvider.translationNotFoundIndicatorRight()`.
+ *
+ * **Note**: These methods automatically add a whitespace between the indicators
+ * and the translation id.
*
- * @param {string} key Locale key.
+ * @param {string} indicator An indicator, could be any string.
*/
- var useLanguage = function (key) {
- $uses = key;
-
- // make sure to store new language key before triggering success event
- if ($storageFactory) {
- Storage.put($translate.storageKey(), $uses);
- }
-
- $rootScope.$emit('$translateChangeSuccess', {language : key});
-
- // inform default interpolator
- defaultInterpolator.setLocale($uses);
-
- var eachInterpolator = function (interpolator, id) {
- interpolatorHashMap[id].setLocale($uses);
- };
- eachInterpolator.displayName = 'eachInterpolatorLocaleSetter';
-
- // inform all others too!
- angular.forEach(interpolatorHashMap, eachInterpolator);
- $rootScope.$emit('$translateChangeEnd', {language : key});
+ this.translationNotFoundIndicator = function (indicator) {
+ this.translationNotFoundIndicatorLeft(indicator);
+ this.translationNotFoundIndicatorRight(indicator);
+ return this;
};
/**
- * @name loadAsync
- * @private
+ * ngdoc function
+ * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicatorLeft
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Kicks off registered async loader using `$injector` and applies existing
- * loader options. When resolved, it updates translation tables accordingly
- * or rejects with given language key.
+ * Sets an indicator which is used when a translation isn't found left to the
+ * translation id.
*
- * @param {string} key Language key.
- * @return {Promise} A promise.
+ * @param {string} indicator An indicator.
*/
- var loadAsync = function (key) {
- if (!key) {
- throw 'No language key specified for loading.';
- }
-
- var deferred = $q.defer();
-
- $rootScope.$emit('$translateLoadingStart', {language : key});
- pendingLoader = true;
-
- var cache = loaderCache;
- if (typeof(cache) === 'string') {
- // getting on-demand instance of loader
- cache = $injector.get(cache);
+ this.translationNotFoundIndicatorLeft = function (indicator) {
+ if (!indicator) {
+ return $notFoundIndicatorLeft;
}
-
- var loaderOptions = angular.extend({}, $loaderOptions, {
- key : key,
- $http : angular.extend({}, {
- cache : cache
- }, $loaderOptions.$http)
- });
-
- var onLoaderSuccess = function (data) {
- var translationTable = {};
- $rootScope.$emit('$translateLoadingSuccess', {language : key});
-
- if (angular.isArray(data)) {
- angular.forEach(data, function (table) {
- angular.extend(translationTable, flatObject(table));
- });
- } else {
- angular.extend(translationTable, flatObject(data));
- }
- pendingLoader = false;
- deferred.resolve({
- key : key,
- table : translationTable
- });
- $rootScope.$emit('$translateLoadingEnd', {language : key});
- };
- onLoaderSuccess.displayName = 'onLoaderSuccess';
-
- var onLoaderError = function (key) {
- $rootScope.$emit('$translateLoadingError', {language : key});
- deferred.reject(key);
- $rootScope.$emit('$translateLoadingEnd', {language : key});
- };
- onLoaderError.displayName = 'onLoaderError';
-
- $injector.get($loaderFactory)(loaderOptions)
- .then(onLoaderSuccess, onLoaderError);
-
- return deferred.promise;
+ $notFoundIndicatorLeft = indicator;
+ return this;
};
- if ($storageFactory) {
- Storage = $injector.get($storageFactory);
-
- if (!Storage.get || !Storage.put) {
- throw new Error('Couldn\'t use storage \'' + $storageFactory + '\', missing get() or put() method!');
- }
- }
-
- // if we have additional interpolations that were added via
- // $translateProvider.addInterpolation(), we have to map'em
- if ($interpolatorFactories.length) {
- var eachInterpolationFactory = function (interpolatorFactory) {
- var interpolator = $injector.get(interpolatorFactory);
- // setting initial locale for each interpolation service
- interpolator.setLocale($preferredLanguage || $uses);
- // make'em recognizable through id
- interpolatorHashMap[interpolator.getInterpolationIdentifier()] = interpolator;
- };
- eachInterpolationFactory.displayName = 'interpolationFactoryAdder';
-
- angular.forEach($interpolatorFactories, eachInterpolationFactory);
- }
-
/**
- * @name getTranslationTable
- * @private
+ * ngdoc function
+ * @name pascalprecht.translate.$translateProvider#translationNotFoundIndicatorLeft
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns a promise that resolves to the translation table
- * or is rejected if an error occurred.
+ * Sets an indicator which is used when a translation isn't found right to the
+ * translation id.
*
- * @param langKey
- * @returns {Q.promise}
+ * @param {string} indicator An indicator.
*/
- var getTranslationTable = function (langKey) {
- var deferred = $q.defer();
- if (Object.prototype.hasOwnProperty.call($translationTable, langKey)) {
- deferred.resolve($translationTable[langKey]);
- } else if (langPromises[langKey]) {
- var onResolve = function (data) {
- translations(data.key, data.table);
- deferred.resolve(data.table);
- };
- onResolve.displayName = 'translationTableResolver';
- langPromises[langKey].then(onResolve, deferred.reject);
- } else {
- deferred.reject();
+ this.translationNotFoundIndicatorRight = function (indicator) {
+ if (!indicator) {
+ return $notFoundIndicatorRight;
}
- return deferred.promise;
+ $notFoundIndicatorRight = indicator;
+ return this;
};
/**
- * @name getFallbackTranslation
- * @private
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#fallbackLanguage
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns a promise that will resolve to the translation
- * or be rejected if no translation was found for the language.
- * This function is currently only used for fallback language translation.
+ * Tells the module which of the registered translation tables to use when missing translations
+ * at initial startup by passing a language key. Similar to `$translateProvider#use`
+ * only that it says which language to **fallback**.
+ *
+ * @param {string||array} langKey A language key.
*
- * @param langKey The language to translate to.
- * @param translationId
- * @param interpolateParams
- * @param Interpolator
- * @param sanitizeStrategy
- * @returns {Q.promise}
*/
- var getFallbackTranslation = function (langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy) {
- var deferred = $q.defer();
-
- var onResolve = function (translationTable) {
- if (Object.prototype.hasOwnProperty.call(translationTable, translationId) && translationTable[translationId] !== null) {
- Interpolator.setLocale(langKey);
- var translation = translationTable[translationId];
- if (translation.substr(0, 2) === '@:') {
- getFallbackTranslation(langKey, translation.substr(2), interpolateParams, Interpolator, sanitizeStrategy)
- .then(deferred.resolve, deferred.reject);
- } else {
- var interpolatedValue = Interpolator.interpolate(translationTable[translationId], interpolateParams, 'service', sanitizeStrategy, translationId);
- interpolatedValue = applyPostProcessing(translationId, translationTable[translationId], interpolatedValue, interpolateParams, langKey);
+ this.fallbackLanguage = function (langKey) {
+ fallbackStack(langKey);
+ return this;
+ };
- deferred.resolve(interpolatedValue);
+ var fallbackStack = function fallbackStack(langKey) {
+ if (langKey) {
+ if (angular.isString(langKey)) {
+ $fallbackWasString = true;
+ $fallbackLanguage = [langKey];
+ } else if (angular.isArray(langKey)) {
+ $fallbackWasString = false;
+ $fallbackLanguage = langKey;
+ }
+ if (angular.isString($preferredLanguage) && indexOf($fallbackLanguage, $preferredLanguage) < 0) {
+ $fallbackLanguage.push($preferredLanguage);
+ }
- }
- Interpolator.setLocale($uses);
+ return this;
+ } else {
+ if ($fallbackWasString) {
+ return $fallbackLanguage[0];
} else {
- deferred.reject();
+ return $fallbackLanguage;
}
- };
- onResolve.displayName = 'fallbackTranslationResolver';
-
- getTranslationTable(langKey).then(onResolve, deferred.reject);
-
- return deferred.promise;
+ }
};
/**
- * @name getFallbackTranslationInstant
- * @private
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#use
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns a translation
- * This function is currently only used for fallback language translation.
+ * Set which translation table to use for translation by given language key. When
+ * trying to 'use' a language which isn't provided, it'll throw an error.
*
- * @param langKey The language to translate to.
- * @param translationId
- * @param interpolateParams
- * @param Interpolator
- * @param sanitizeStrategy sanitize strategy override
+ * You actually don't have to use this method since `$translateProvider#preferredLanguage`
+ * does the job too.
*
- * @returns {string} translation
+ * @param {string} langKey A language key.
*/
- var getFallbackTranslationInstant = function (langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy) {
- var result, translationTable = $translationTable[langKey];
-
- if (translationTable && Object.prototype.hasOwnProperty.call(translationTable, translationId) && translationTable[translationId] !== null) {
- Interpolator.setLocale(langKey);
- result = Interpolator.interpolate(translationTable[translationId], interpolateParams, 'filter', sanitizeStrategy, translationId);
- result = applyPostProcessing(translationId, translationTable[translationId], result, interpolateParams, langKey, sanitizeStrategy);
- // workaround for TrustedValueHolderType
- if (!angular.isString(result) && angular.isFunction(result.$$unwrapTrustedValue)) {
- var result2 = result.$$unwrapTrustedValue();
- if (result2.substr(0, 2) === '@:') {
- return getFallbackTranslationInstant(langKey, result2.substr(2), interpolateParams, Interpolator, sanitizeStrategy);
- }
- } else if (result.substr(0, 2) === '@:') {
- return getFallbackTranslationInstant(langKey, result.substr(2), interpolateParams, Interpolator, sanitizeStrategy);
+ this.use = function (langKey) {
+ if (langKey) {
+ if (!$translationTable[langKey] && !$loaderFactory) {
+ // only throw an error, when not loading translation data asynchronously
+ throw new Error('$translateProvider couldn\'t find translationTable for langKey: \'' + langKey + '\'');
}
- Interpolator.setLocale($uses);
+ $uses = langKey;
+ return this;
}
-
- return result;
+ return $uses;
};
-
/**
- * @name translateByHandler
- * @private
- *
- * Translate by missing translation handler.
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#resolveClientLocale
+ * @methodOf pascalprecht.translate.$translateProvider
*
- * @param translationId
- * @param interpolateParams
- * @param defaultTranslationText
- * @param sanitizeStrategy sanitize strategy override
+ * @description
+ * This returns the current browser/client's language key. The result is processed with the configured uniform tag resolver.
*
- * @returns translation created by $missingTranslationHandler or translationId is $missingTranslationHandler is
- * absent
+ * @returns {string} the current client/browser language key
*/
- var translateByHandler = function (translationId, interpolateParams, defaultTranslationText, sanitizeStrategy) {
- // If we have a handler factory - we might also call it here to determine if it provides
- // a default text for a translationid that can't be found anywhere in our tables
- if ($missingTranslationHandlerFactory) {
- return $injector.get($missingTranslationHandlerFactory)(translationId, $uses, interpolateParams, defaultTranslationText, sanitizeStrategy);
- } else {
- return translationId;
- }
+ this.resolveClientLocale = function () {
+ return getLocale();
};
/**
- * @name resolveForFallbackLanguage
- * @private
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateProvider#storageKey
+ * @methodOf pascalprecht.translate.$translateProvider
*
- * Recursive helper function for fallbackTranslation that will sequentially look
- * for a translation in the fallbackLanguages starting with fallbackLanguageIndex.
+ * @description
+ * Tells the module which key must represent the choosed language by a user in the storage.
*
- * @param fallbackLanguageIndex
- * @param translationId
- * @param interpolateParams
- * @param Interpolator
- * @param defaultTranslationText
- * @param sanitizeStrategy
- * @returns {Q.promise} Promise that will resolve to the translation.
+ * @param {string} key A key for the storage.
*/
- var resolveForFallbackLanguage = function (fallbackLanguageIndex, translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy) {
- var deferred = $q.defer();
+ var storageKey = function storageKey(key) {
+ if (!key) {
+ if ($storagePrefix) {
+ return $storagePrefix + $storageKey;
+ }
+ return $storageKey;
+ }
+ $storageKey = key;
+ return this;
+ };
- if (fallbackLanguageIndex < $fallbackLanguage.length) {
- var langKey = $fallbackLanguage[fallbackLanguageIndex];
- getFallbackTranslation(langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy).then(
- function (data) {
- deferred.resolve(data);
- },
- function () {
- // Look in the next fallback language for a translation.
- // It delays the resolving by passing another promise to resolve.
- return resolveForFallbackLanguage(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy).then(deferred.resolve, deferred.reject);
- }
- );
- } else {
- // No translation found in any fallback language
- // if a default translation text is set in the directive, then return this as a result
- if (defaultTranslationText) {
- deferred.resolve(defaultTranslationText);
- } else {
- var missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, defaultTranslationText);
-
- // if no default translation is set and an error handler is defined, send it to the handler
- // and then return the result if it isn't undefined
- if ($missingTranslationHandlerFactory && missingTranslationHandlerTranslation) {
- deferred.resolve(missingTranslationHandlerTranslation);
- } else {
- deferred.reject(applyNotFoundIndicators(translationId));
- }
- }
- }
- return deferred.promise;
- };
-
- /**
- * @name resolveForFallbackLanguageInstant
- * @private
- *
- * Recursive helper function for fallbackTranslation that will sequentially look
- * for a translation in the fallbackLanguages starting with fallbackLanguageIndex.
- *
- * @param fallbackLanguageIndex
- * @param translationId
- * @param interpolateParams
- * @param Interpolator
- * @param sanitizeStrategy
- * @returns {string} translation
- */
- var resolveForFallbackLanguageInstant = function (fallbackLanguageIndex, translationId, interpolateParams, Interpolator, sanitizeStrategy) {
- var result;
-
- if (fallbackLanguageIndex < $fallbackLanguage.length) {
- var langKey = $fallbackLanguage[fallbackLanguageIndex];
- result = getFallbackTranslationInstant(langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy);
- if (!result && result !== '') {
- result = resolveForFallbackLanguageInstant(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator);
- }
- }
- return result;
- };
-
- /**
- * Translates with the usage of the fallback languages.
- *
- * @param translationId
- * @param interpolateParams
- * @param Interpolator
- * @param defaultTranslationText
- * @param sanitizeStrategy
- * @returns {Q.promise} Promise, that resolves to the translation.
- */
- var fallbackTranslation = function (translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy) {
- // Start with the fallbackLanguage with index 0
- return resolveForFallbackLanguage((startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex), translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy);
- };
-
- /**
- * Translates with the usage of the fallback languages.
- *
- * @param translationId
- * @param interpolateParams
- * @param Interpolator
- * @param sanitizeStrategy
- * @returns {String} translation
- */
- var fallbackTranslationInstant = function (translationId, interpolateParams, Interpolator, sanitizeStrategy) {
- // Start with the fallbackLanguage with index 0
- return resolveForFallbackLanguageInstant((startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex), translationId, interpolateParams, Interpolator, sanitizeStrategy);
- };
-
- var determineTranslation = function (translationId, interpolateParams, interpolationId, defaultTranslationText, uses, sanitizeStrategy) {
-
- var deferred = $q.defer();
-
- var table = uses ? $translationTable[uses] : $translationTable,
- Interpolator = (interpolationId) ? interpolatorHashMap[interpolationId] : defaultInterpolator;
-
- // if the translation id exists, we can just interpolate it
- if (table && Object.prototype.hasOwnProperty.call(table, translationId) && table[translationId] !== null) {
- var translation = table[translationId];
-
- // If using link, rerun $translate with linked translationId and return it
- if (translation.substr(0, 2) === '@:') {
-
- $translate(translation.substr(2), interpolateParams, interpolationId, defaultTranslationText, uses)
- .then(deferred.resolve, deferred.reject);
- } else {
- //
- var resolvedTranslation = Interpolator.interpolate(translation, interpolateParams, 'service', sanitizeStrategy, translationId);
- resolvedTranslation = applyPostProcessing(translationId, translation, resolvedTranslation, interpolateParams, uses);
- deferred.resolve(resolvedTranslation);
- }
- } else {
- var missingTranslationHandlerTranslation;
- // for logging purposes only (as in $translateMissingTranslationHandlerLog), value is not returned to promise
- if ($missingTranslationHandlerFactory && !pendingLoader) {
- missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, defaultTranslationText);
- }
-
- // since we couldn't translate the inital requested translation id,
- // we try it now with one or more fallback languages, if fallback language(s) is
- // configured.
- if (uses && $fallbackLanguage && $fallbackLanguage.length) {
- fallbackTranslation(translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy)
- .then(function (translation) {
- deferred.resolve(translation);
- }, function (_translationId) {
- deferred.reject(applyNotFoundIndicators(_translationId));
- });
- } else if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
- // looks like the requested translation id doesn't exists.
- // Now, if there is a registered handler for missing translations and no
- // asyncLoader is pending, we execute the handler
- if (defaultTranslationText) {
- deferred.resolve(defaultTranslationText);
- } else {
- deferred.resolve(missingTranslationHandlerTranslation);
- }
- } else {
- if (defaultTranslationText) {
- deferred.resolve(defaultTranslationText);
- } else {
- deferred.reject(applyNotFoundIndicators(translationId));
- }
- }
- }
- return deferred.promise;
- };
-
- var determineTranslationInstant = function (translationId, interpolateParams, interpolationId, uses, sanitizeStrategy) {
-
- var result, table = uses ? $translationTable[uses] : $translationTable,
- Interpolator = defaultInterpolator;
-
- // if the interpolation id exists use custom interpolator
- if (interpolatorHashMap && Object.prototype.hasOwnProperty.call(interpolatorHashMap, interpolationId)) {
- Interpolator = interpolatorHashMap[interpolationId];
- }
-
- // if the translation id exists, we can just interpolate it
- if (table && Object.prototype.hasOwnProperty.call(table, translationId) && table[translationId] !== null) {
- var translation = table[translationId];
-
- // If using link, rerun $translate with linked translationId and return it
- if (translation.substr(0, 2) === '@:') {
- result = determineTranslationInstant(translation.substr(2), interpolateParams, interpolationId, uses, sanitizeStrategy);
- } else {
- result = Interpolator.interpolate(translation, interpolateParams, 'filter', sanitizeStrategy, translationId);
- result = applyPostProcessing(translationId, translation, result, interpolateParams, uses, sanitizeStrategy);
- }
- } else {
- var missingTranslationHandlerTranslation;
- // for logging purposes only (as in $translateMissingTranslationHandlerLog), value is not returned to promise
- if ($missingTranslationHandlerFactory && !pendingLoader) {
- missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, sanitizeStrategy);
- }
-
- // since we couldn't translate the inital requested translation id,
- // we try it now with one or more fallback languages, if fallback language(s) is
- // configured.
- if (uses && $fallbackLanguage && $fallbackLanguage.length) {
- fallbackIndex = 0;
- result = fallbackTranslationInstant(translationId, interpolateParams, Interpolator, sanitizeStrategy);
- } else if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
- // looks like the requested translation id doesn't exists.
- // Now, if there is a registered handler for missing translations and no
- // asyncLoader is pending, we execute the handler
- result = missingTranslationHandlerTranslation;
- } else {
- result = applyNotFoundIndicators(translationId);
- }
- }
-
- return result;
- };
-
- var clearNextLangAndPromise = function (key) {
- if ($nextLang === key) {
- $nextLang = undefined;
- }
- langPromises[key] = undefined;
- };
-
- var applyPostProcessing = function (translationId, translation, resolvedTranslation, interpolateParams, uses, sanitizeStrategy) {
- var fn = postProcessFn;
-
- if (fn) {
-
- if (typeof(fn) === 'string') {
- // getting on-demand instance
- fn = $injector.get(fn);
- }
- if (fn) {
- return fn(translationId, translation, resolvedTranslation, interpolateParams, uses, sanitizeStrategy);
- }
- }
-
- return resolvedTranslation;
- };
-
- var loadTranslationsIfMissing = function (key) {
- if (!$translationTable[key] && $loaderFactory && !langPromises[key]) {
- langPromises[key] = loadAsync(key).then(function (translation) {
- translations(translation.key, translation.table);
- return translation;
- });
- }
- };
+ this.storageKey = storageKey;
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#preferredLanguage
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useUrlLoader
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the language key for the preferred language.
- *
- * @param {string} langKey language String or Array to be used as preferredLanguage (changing at runtime)
+ * Tells angular-translate to use `$translateUrlLoader` extension service as loader.
*
- * @return {string} preferred language key
+ * @param {string} url Url
+ * @param {Object=} options Optional configuration object
*/
- $translate.preferredLanguage = function (langKey) {
- if (langKey) {
- setupPreferredLanguage(langKey);
- }
- return $preferredLanguage;
+ this.useUrlLoader = function (url, options) {
+ return this.useLoader('$translateUrlLoader', angular.extend({ url: url }, options));
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#cloakClassName
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useStaticFilesLoader
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the configured class name for `translate-cloak` directive.
+ * Tells angular-translate to use `$translateStaticFilesLoader` extension service as loader.
*
- * @return {string} cloakClassName
+ * @param {Object=} options Optional configuration object
*/
- $translate.cloakClassName = function () {
- return $cloakClassName;
+ this.useStaticFilesLoader = function (options) {
+ return this.useLoader('$translateStaticFilesLoader', options);
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#nestedObjectDelimeter
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useLoader
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the configured delimiter for nested namespaces.
+ * Tells angular-translate to use any other service as loader.
*
- * @return {string} nestedObjectDelimeter
+ * @param {string} loaderFactory Factory name to use
+ * @param {Object=} options Optional configuration object
*/
- $translate.nestedObjectDelimeter = function () {
- return $nestedObjectDelimeter;
+ this.useLoader = function (loaderFactory, options) {
+ $loaderFactory = loaderFactory;
+ $loaderOptions = options || {};
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#fallbackLanguage
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useLocalStorage
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the language key for the fallback languages or sets a new fallback stack.
- *
- * @param {string=} langKey language String or Array of fallback languages to be used (to change stack at runtime)
+ * Tells angular-translate to use `$translateLocalStorage` service as storage layer.
*
- * @return {string||array} fallback language key
*/
- $translate.fallbackLanguage = function (langKey) {
- if (langKey !== undefined && langKey !== null) {
- fallbackStack(langKey);
-
- // as we might have an async loader initiated and a new translation language might have been defined
- // we need to add the promise to the stack also. So - iterate.
- if ($loaderFactory) {
- if ($fallbackLanguage && $fallbackLanguage.length) {
- for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
- if (!langPromises[$fallbackLanguage[i]]) {
- langPromises[$fallbackLanguage[i]] = loadAsync($fallbackLanguage[i]);
- }
- }
- }
- }
- $translate.use($translate.use());
- }
- if ($fallbackWasString) {
- return $fallbackLanguage[0];
- } else {
- return $fallbackLanguage;
- }
-
+ this.useLocalStorage = function () {
+ return this.useStorage('$translateLocalStorage');
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#useFallbackLanguage
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useCookieStorage
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Sets the first key of the fallback language stack to be used for translation.
- * Therefore all languages in the fallback array BEFORE this key will be skipped!
- *
- * @param {string=} langKey Contains the langKey the iteration shall start with. Set to false if you want to
- * get back to the whole stack
+ * Tells angular-translate to use `$translateCookieStorage` service as storage layer.
*/
- $translate.useFallbackLanguage = function (langKey) {
- if (langKey !== undefined && langKey !== null) {
- if (!langKey) {
- startFallbackIteration = 0;
- } else {
- var langKeyPosition = indexOf($fallbackLanguage, langKey);
- if (langKeyPosition > -1) {
- startFallbackIteration = langKeyPosition;
- }
- }
-
- }
-
+ this.useCookieStorage = function () {
+ return this.useStorage('$translateCookieStorage');
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#proposedLanguage
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useStorage
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the language key of language that is currently loaded asynchronously.
- *
- * @return {string} language key
+ * Tells angular-translate to use custom service as storage layer.
*/
- $translate.proposedLanguage = function () {
- return $nextLang;
+ this.useStorage = function (storageFactory) {
+ $storageFactory = storageFactory;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#storage
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#storagePrefix
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns registered storage.
+ * Sets prefix for storage key.
*
- * @return {object} Storage
+ * @param {string} prefix Storage key prefix
*/
- $translate.storage = function () {
- return Storage;
+ this.storagePrefix = function (prefix) {
+ if (!prefix) {
+ return prefix;
+ }
+ $storagePrefix = prefix;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#negotiateLocale
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useMissingTranslationHandlerLog
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns a language key based on available languages and language aliases. If a
- * language key cannot be resolved, returns undefined.
+ * Tells angular-translate to use built-in log handler when trying to translate
+ * a translation Id which doesn't exist.
*
- * If no or a falsy key is given, returns undefined.
+ * This is actually a shortcut method for `useMissingTranslationHandler()`.
*
- * @param {string} [key] Language key
- * @return {string|undefined} Language key or undefined if no language key is found.
*/
- $translate.negotiateLocale = negotiateLocale;
+ this.useMissingTranslationHandlerLog = function () {
+ return this.useMissingTranslationHandler('$translateMissingTranslationHandlerLog');
+ };
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#use
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useMissingTranslationHandler
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Tells angular-translate which language to use by given language key. This method is
- * used to change language at runtime. It also takes care of storing the language
- * key in a configured store to let your app remember the choosed language.
- *
- * When trying to 'use' a language which isn't available it tries to load it
- * asynchronously with registered loaders.
+ * Expects a factory name which later gets instantiated with `$injector`.
+ * This method can be used to tell angular-translate to use a custom
+ * missingTranslationHandler. Just build a factory which returns a function
+ * and expects a translation id as argument.
*
- * Returns promise object with loaded language file data or string of the currently used language.
+ * Example:
+ *
+ * app.config(function ($translateProvider) {
+ * $translateProvider.useMissingTranslationHandler('customHandler');
+ * });
*
- * If no or a falsy key is given it returns the currently used language key.
- * The returned string will be ```undefined``` if setting up $translate hasn't finished.
- * @example
- * $translate.use("en_US").then(function(data){
- * $scope.text = $translate("HELLO");
- * });
+ * app.factory('customHandler', function (dep1, dep2) {
+ * return function (translationId) {
+ * // something with translationId and dep1 and dep2
+ * };
+ * });
+ *
*
- * @param {string} [key] Language key
- * @return {object|string} Promise with loaded language data or the language key if a falsy param was given.
+ * @param {string} factory Factory name
*/
- $translate.use = function (key) {
- if (!key) {
- return $uses;
- }
-
- var deferred = $q.defer();
- deferred.promise.then(null, angular.noop); // AJS "Possibly unhandled rejection"
-
- $rootScope.$emit('$translateChangeStart', {language : key});
-
- // Try to get the aliased language key
- var aliasedKey = negotiateLocale(key);
- // Ensure only registered language keys will be loaded
- if ($availableLanguageKeys.length > 0 && !aliasedKey) {
- return $q.reject(key);
- }
-
- if (aliasedKey) {
- key = aliasedKey;
- }
-
- // if there isn't a translation table for the language we've requested,
- // we load it asynchronously
- $nextLang = key;
- if (($forceAsyncReloadEnabled || !$translationTable[key]) && $loaderFactory && !langPromises[key]) {
- langPromises[key] = loadAsync(key).then(function (translation) {
- translations(translation.key, translation.table);
- deferred.resolve(translation.key);
- if ($nextLang === key) {
- useLanguage(translation.key);
- }
- return translation;
- }, function (key) {
- $rootScope.$emit('$translateChangeError', {language : key});
- deferred.reject(key);
- $rootScope.$emit('$translateChangeEnd', {language : key});
- return $q.reject(key);
- });
- langPromises[key]['finally'](function () {
- clearNextLangAndPromise(key);
- }).catch(angular.noop); // we don't care about errors (clearing)
- } else if (langPromises[key]) {
- // we are already loading this asynchronously
- // resolve our new deferred when the old langPromise is resolved
- langPromises[key].then(function (translation) {
- if ($nextLang === translation.key) {
- useLanguage(translation.key);
- }
- deferred.resolve(translation.key);
- return translation;
- }, function (key) {
- // find first available fallback language if that request has failed
- if (!$uses && $fallbackLanguage && $fallbackLanguage.length > 0 && $fallbackLanguage[0] !== key) {
- return $translate.use($fallbackLanguage[0]).then(deferred.resolve, deferred.reject);
- } else {
- return deferred.reject(key);
- }
- });
- } else {
- deferred.resolve(key);
- useLanguage(key);
- }
-
- return deferred.promise;
+ this.useMissingTranslationHandler = function (factory) {
+ $missingTranslationHandlerFactory = factory;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#resolveClientLocale
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#usePostCompiling
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * This returns the current browser/client's language key. The result is processed with the configured uniform tag resolver.
+ * If post compiling is enabled, all translated values will be processed
+ * again with AngularJS' $compile.
*
- * @returns {string} the current client/browser language key
+ * Example:
+ *
+ * app.config(function ($translateProvider) {
+ * $translateProvider.usePostCompiling(true);
+ * });
+ *
+ *
+ * @param {string} factory Factory name
*/
- $translate.resolveClientLocale = function () {
- return getLocale();
+ this.usePostCompiling = function (value) {
+ $postCompilingEnabled = !!value;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#storageKey
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#forceAsyncReload
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the key for the storage.
+ * If force async reload is enabled, async loader will always be called
+ * even if $translationTable already contains the language key, adding
+ * possible new entries to the $translationTable.
+ *
+ * Example:
+ *
+ * app.config(function ($translateProvider) {
+ * $translateProvider.forceAsyncReload(true);
+ * });
+ *
*
- * @return {string} storage key
+ * @param {boolean} value - valid values are true or false
*/
- $translate.storageKey = function () {
- return storageKey();
+ this.forceAsyncReload = function (value) {
+ $forceAsyncReloadEnabled = !!value;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#isPostCompilingEnabled
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#uniformLanguageTag
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns whether post compiling is enabled or not
+ * Tells angular-translate which language tag should be used as a result when determining
+ * the current browser language.
*
- * @return {bool} storage key
- */
- $translate.isPostCompilingEnabled = function () {
- return $postCompilingEnabled;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translate#isForceAsyncReloadEnabled
- * @methodOf pascalprecht.translate.$translate
+ * This setting must be set before invoking {@link pascalprecht.translate.$translateProvider#methods_determinePreferredLanguage determinePreferredLanguage()}.
*
- * @description
- * Returns whether force async reload is enabled or not
+ *
+ * $translateProvider
+ * .uniformLanguageTag('bcp47')
+ * .determinePreferredLanguage()
+ *
*
- * @return {boolean} forceAsyncReload value
- */
- $translate.isForceAsyncReloadEnabled = function () {
- return $forceAsyncReloadEnabled;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translate#isKeepContent
- * @methodOf pascalprecht.translate.$translate
+ * The resolver currently supports:
+ * * default
+ * (traditionally: hyphens will be converted into underscores, i.e. en-US => en_US)
+ * en-US => en_US
+ * en_US => en_US
+ * en-us => en_us
+ * * java
+ * like default, but the second part will be always in uppercase
+ * en-US => en_US
+ * en_US => en_US
+ * en-us => en_US
+ * * BCP 47 (RFC 4646 & 4647)
+ * en-US => en-US
+ * en_US => en-US
+ * en-us => en-US
*
- * @description
- * Returns whether keepContent or not
+ * See also:
+ * * http://en.wikipedia.org/wiki/IETF_language_tag
+ * * http://www.w3.org/International/core/langtags/
+ * * http://tools.ietf.org/html/bcp47
*
- * @return {boolean} keepContent value
+ * @param {string|object} options - options (or standard)
+ * @param {string} options.standard - valid values are 'default', 'bcp47', 'java'
*/
- $translate.isKeepContent = function () {
- return $keepContent;
+ this.uniformLanguageTag = function (options) {
+
+ if (!options) {
+ options = {};
+ } else if (angular.isString(options)) {
+ options = {
+ standard: options
+ };
+ }
+
+ uniformLanguageTagResolver = options.standard;
+
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#refresh
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#determinePreferredLanguage
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Refreshes a translation table pointed by the given langKey. If langKey is not specified,
- * the module will drop all existent translation tables and load new version of those which
- * are currently in use.
- *
- * Refresh means that the module will drop target translation table and try to load it again.
- *
- * In case there are no loaders registered the refresh() method will throw an Error.
- *
- * If the module is able to refresh translation tables refresh() method will broadcast
- * $translateRefreshStart and $translateRefreshEnd events.
+ * Tells angular-translate to try to determine on its own which language key
+ * to set as preferred language. When `fn` is given, angular-translate uses it
+ * to determine a language key, otherwise it uses the built-in `getLocale()`
+ * method.
*
- * @example
- * // this will drop all currently existent translation tables and reload those which are
- * // currently in use
- * $translate.refresh();
- * // this will refresh a translation table for the en_US language
- * $translate.refresh('en_US');
+ * The `getLocale()` returns a language key in the format `[lang]_[country]` or
+ * `[lang]` depending on what the browser provides.
*
- * @param {string} langKey A language key of the table, which has to be refreshed
+ * Use this method at your own risk, since not all browsers return a valid
+ * locale (see {@link pascalprecht.translate.$translateProvider#methods_uniformLanguageTag uniformLanguageTag()}).
*
- * @return {promise} Promise, which will be resolved in case a translation tables refreshing
- * process is finished successfully, and reject if not.
+ * @param {Function=} fn Function to determine a browser's locale
*/
- $translate.refresh = function (langKey) {
- if (!$loaderFactory) {
- throw new Error('Couldn\'t refresh translation table, no loader registered!');
- }
-
- $rootScope.$emit('$translateRefreshStart', {language : langKey});
-
- var deferred = $q.defer(), updatedLanguages = {};
-
- //private helper
- function loadNewData(languageKey) {
- var promise = loadAsync(languageKey);
- //update the load promise cache for this language
- langPromises[languageKey] = promise;
- //register a data handler for the promise
- promise.then(function (data) {
- //clear the cache for this language
- $translationTable[languageKey] = {};
- //add the new data for this language
- translations(languageKey, data.table);
- //track that we updated this language
- updatedLanguages[languageKey] = true;
- },
- //handle rejection to appease the $q validation
- angular.noop);
- return promise;
- }
-
- //set up post-processing
- deferred.promise.then(
- function () {
- for (var key in $translationTable) {
- if ($translationTable.hasOwnProperty(key)) {
- //delete cache entries that were not updated
- if (!(key in updatedLanguages)) {
- delete $translationTable[key];
- }
- }
- }
- if ($uses) {
- useLanguage($uses);
- }
- },
- //handle rejection to appease the $q validation
- angular.noop
- ).finally(
- function () {
- $rootScope.$emit('$translateRefreshEnd', {language : langKey});
- }
- );
+ this.determinePreferredLanguage = function (fn) {
- if (!langKey) {
- // if there's no language key specified we refresh ALL THE THINGS!
- var languagesToReload = $fallbackLanguage && $fallbackLanguage.slice() || [];
- if ($uses && languagesToReload.indexOf($uses) === -1) {
- languagesToReload.push($uses);
- }
- $q.all(languagesToReload.map(loadNewData)).then(deferred.resolve, deferred.reject);
-
- } else if ($translationTable[langKey]) {
- //just refresh the specified language cache
- loadNewData(langKey).then(deferred.resolve, deferred.reject);
+ var locale = fn && angular.isFunction(fn) ? fn() : getLocale();
+ if (!$availableLanguageKeys.length) {
+ $preferredLanguage = locale;
} else {
- deferred.reject();
+ $preferredLanguage = negotiateLocale(locale) || locale;
}
- return deferred.promise;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#instant
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#registerAvailableLanguageKeys
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns a translation instantly from the internal state of loaded translation. All rules
- * regarding the current language, the preferred language of even fallback languages will be
- * used except any promise handling. If a language was not found, an asynchronous loading
- * will be invoked in the background.
+ * Registers a set of language keys the app will work with. Use this method in
+ * combination with
+ * {@link pascalprecht.translate.$translateProvider#determinePreferredLanguage determinePreferredLanguage}.
+ * When available languages keys are registered, angular-translate
+ * tries to find the best fitting language key depending on the browsers locale,
+ * considering your language key convention.
*
- * @param {string|array} translationId A token which represents a translation id
- * This can be optionally an array of translation ids which
- * results that the function's promise returns an object where
- * each key is the translation id and the value the translation.
- * @param {object} interpolateParams Params
- * @param {string} interpolationId The id of the interpolation to use
- * @param {string} forceLanguage A language to be used instead of the current language
- * @param {string} sanitizeStrategy force sanitize strategy for this call instead of using the configured one
- *
- * @return {string|object} translation
+ * @param {object} languageKeys Array of language keys the your app will use
+ * @param {object=} aliases Alias map.
*/
- $translate.instant = function (translationId, interpolateParams, interpolationId, forceLanguage, sanitizeStrategy) {
-
- // we don't want to re-negotiate $uses
- var uses = (forceLanguage && forceLanguage !== $uses) ? // we don't want to re-negotiate $uses
- (negotiateLocale(forceLanguage) || forceLanguage) : $uses;
-
- // Detect undefined and null values to shorten the execution and prevent exceptions
- if (translationId === null || angular.isUndefined(translationId)) {
- return translationId;
- }
-
- // Check forceLanguage is present
- if (forceLanguage) {
- loadTranslationsIfMissing(forceLanguage);
- }
-
- // Duck detection: If the first argument is an array, a bunch of translations was requested.
- // The result is an object.
- if (angular.isArray(translationId)) {
- var results = {};
- for (var i = 0, c = translationId.length; i < c; i++) {
- results[translationId[i]] = $translate.instant(translationId[i], interpolateParams, interpolationId, forceLanguage, sanitizeStrategy);
- }
- return results;
- }
-
- // We discarded unacceptable values. So we just need to verify if translationId is empty String
- if (angular.isString(translationId) && translationId.length < 1) {
- return translationId;
- }
-
- // trim off any whitespace
- if (translationId) {
- translationId = trim.apply(translationId);
- }
-
- var result, possibleLangKeys = [];
- if ($preferredLanguage) {
- possibleLangKeys.push($preferredLanguage);
- }
- if (uses) {
- possibleLangKeys.push(uses);
- }
- if ($fallbackLanguage && $fallbackLanguage.length) {
- possibleLangKeys = possibleLangKeys.concat($fallbackLanguage);
- }
- for (var j = 0, d = possibleLangKeys.length; j < d; j++) {
- var possibleLangKey = possibleLangKeys[j];
- if ($translationTable[possibleLangKey]) {
- if (typeof $translationTable[possibleLangKey][translationId] !== 'undefined') {
- result = determineTranslationInstant(translationId, interpolateParams, interpolationId, uses, sanitizeStrategy);
- }
- }
- if (typeof result !== 'undefined') {
- break;
- }
- }
-
- if (!result && result !== '') {
- if ($notFoundIndicatorLeft || $notFoundIndicatorRight) {
- result = applyNotFoundIndicators(translationId);
- } else {
- // Return translation of default interpolator if not found anything.
- result = defaultInterpolator.interpolate(translationId, interpolateParams, 'filter', sanitizeStrategy);
-
- // looks like the requested translation id doesn't exists.
- // Now, if there is a registered handler for missing translations and no
- // asyncLoader is pending, we execute the handler
- var missingTranslationHandlerTranslation;
- if ($missingTranslationHandlerFactory && !pendingLoader) {
- missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, sanitizeStrategy);
- }
-
- if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
- result = missingTranslationHandlerTranslation;
- }
+ this.registerAvailableLanguageKeys = function (languageKeys, aliases) {
+ if (languageKeys) {
+ $availableLanguageKeys = languageKeys;
+ if (aliases) {
+ $languageKeyAliases = aliases;
}
+ return this;
}
-
- return result;
+ return $availableLanguageKeys;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#versionInfo
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#useLoaderCache
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the current version information for the angular-translate library
+ * Registers a cache for internal $http based loaders.
+ * {@link pascalprecht.translate.$translationCache $translationCache}.
+ * When false the cache will be disabled (default). When true or undefined
+ * the cache will be a default (see $cacheFactory). When an object it will
+ * be treat as a cache object itself: the usage is $http({cache: cache})
*
- * @return {string} angular-translate version
+ * @param {object} cache boolean, string or cache-object
*/
- $translate.versionInfo = function () {
- return version;
+ this.useLoaderCache = function (cache) {
+ if (cache === false) {
+ // disable cache
+ loaderCache = undefined;
+ } else if (cache === true) {
+ // enable cache using AJS defaults
+ loaderCache = true;
+ } else if (typeof cache === 'undefined') {
+ // enable cache using default
+ loaderCache = '$translationCache';
+ } else if (cache) {
+ // enable cache using given one (see $cacheFactory)
+ loaderCache = cache;
+ }
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#loaderCache
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#directivePriority
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns the defined loaderCache.
+ * Sets the default priority of the translate directive. The standard value is `0`.
+ * Calling this function without an argument will return the current value.
*
- * @return {boolean|string|object} current value of loaderCache
+ * @param {number} priority for the translate-directive
*/
- $translate.loaderCache = function () {
- return loaderCache;
- };
-
- // internal purpose only
- $translate.directivePriority = function () {
- return directivePriority;
- };
-
- // internal purpose only
- $translate.statefulFilter = function () {
- return statefulFilter;
+ this.directivePriority = function (priority) {
+ if (priority === undefined) {
+ // getter
+ return directivePriority;
+ } else {
+ // setter with chaining
+ directivePriority = priority;
+ return this;
+ }
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#isReady
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#statefulFilter
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Returns whether the service is "ready" to translate (i.e. loading 1st language).
+ * Since AngularJS 1.3, filters which are not stateless (depending at the scope)
+ * have to explicit define this behavior.
+ * Sets whether the translate filter should be stateful or stateless. The standard value is `true`
+ * meaning being stateful.
+ * Calling this function without an argument will return the current value.
*
- * See also {@link pascalprecht.translate.$translate#methods_onReady onReady()}.
- *
- * @return {boolean} current value of ready
+ * @param {boolean} state - defines the state of the filter
*/
- $translate.isReady = function () {
- return $isReady;
+ this.statefulFilter = function (state) {
+ if (state === undefined) {
+ // getter
+ return statefulFilter;
+ } else {
+ // setter with chaining
+ statefulFilter = state;
+ return this;
+ }
};
- var $onReadyDeferred = $q.defer();
- $onReadyDeferred.promise.then(function () {
- $isReady = true;
- });
-
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#onReady
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#postProcess
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * Calls the function provided or resolved the returned promise after the service is "ready" to translate (i.e. loading 1st language).
+ * The post processor will be intercept right after the translation result. It can modify the result.
*
- * See also {@link pascalprecht.translate.$translate#methods_isReady isReady()}.
- *
- * @param {Function=} fn Function to invoke when service is ready
- * @return {object} Promise resolved when service is ready
+ * @param {object} fn Function or service name (string) to be called after the translation value has been set / resolved. The function itself will enrich every value being processed and then continue the normal resolver process
*/
- $translate.onReady = function (fn) {
- var deferred = $q.defer();
- if (angular.isFunction(fn)) {
- deferred.promise.then(fn);
- }
- if ($isReady) {
- deferred.resolve();
+ this.postProcess = function (fn) {
+ if (fn) {
+ postProcessFn = fn;
} else {
- $onReadyDeferred.promise.then(deferred.resolve);
+ postProcessFn = undefined;
}
- return deferred.promise;
+ return this;
};
/**
* @ngdoc function
- * @name pascalprecht.translate.$translate#getAvailableLanguageKeys
- * @methodOf pascalprecht.translate.$translate
+ * @name pascalprecht.translate.$translateProvider#keepContent
+ * @methodOf pascalprecht.translate.$translateProvider
*
* @description
- * This function simply returns the registered language keys being defined before in the config phase
- * With this, an application can use the array to provide a language selection dropdown or similar
- * without any additional effort
+ * If keepContent is set to true than translate directive will always use innerHTML
+ * as a default translation
+ *
+ * Example:
+ *
+ * app.config(function ($translateProvider) {
+ * $translateProvider.keepContent(true);
+ * });
+ *
*
- * @returns {object} returns the list of possibly registered language keys and mapping or null if not defined
+ * @param {boolean} value - valid values are true or false
*/
- $translate.getAvailableLanguageKeys = function () {
- if ($availableLanguageKeys.length > 0) {
- return $availableLanguageKeys;
- }
- return null;
+ this.keepContent = function (value) {
+ $keepContent = !!value;
+ return this;
};
/**
- * @ngdoc function
- * @name pascalprecht.translate.$translate#getTranslationTable
- * @methodOf pascalprecht.translate.$translate
+ * @ngdoc object
+ * @name pascalprecht.translate.$translate
+ * @requires $interpolate
+ * @requires $log
+ * @requires $rootScope
+ * @requires $q
*
* @description
- * Returns translation table by the given language key.
+ * The `$translate` service is the actual core of angular-translate. It expects a translation id
+ * and optional interpolate parameters to translate contents.
*
- * Unless a language is provided it returns a translation table of the current one.
- * Note: If translation dictionary is currently downloading or in progress
- * it will return null.
+ *
+ * $translate('HEADLINE_TEXT').then(function (translation) {
+ * $scope.translatedText = translation;
+ * });
+ *
*
- * @param {string} langKey A token which represents a translation id
- *
- * @return {object} a copy of angular-translate $translationTable
+ * @param {string|array} translationId A token which represents a translation id
+ * This can be optionally an array of translation ids which
+ * results that the function returns an object where each key
+ * is the translation id and the value the translation.
+ * @param {object=} interpolateParams An object hash for dynamic values
+ * @param {string} interpolationId The id of the interpolation to use
+ * @param {string} defaultTranslationText the optional default translation text that is written as
+ * as default text in case it is not found in any configured language
+ * @param {string} forceLanguage A language to be used instead of the current language
+ * @returns {object} promise
*/
- $translate.getTranslationTable = function (langKey) {
- langKey = langKey || $translate.use();
- if (langKey && $translationTable[langKey]) {
- return angular.copy($translationTable[langKey]);
- }
- return null;
- };
-
- // Whenever $translateReady is being fired, this will ensure the state of $isReady
- var globalOnReadyListener = $rootScope.$on('$translateReady', function () {
- $onReadyDeferred.resolve();
- globalOnReadyListener(); // one time only
- globalOnReadyListener = null;
- });
- var globalOnChangeListener = $rootScope.$on('$translateChangeEnd', function () {
- $onReadyDeferred.resolve();
- globalOnChangeListener(); // one time only
- globalOnChangeListener = null;
- });
-
- if ($loaderFactory) {
-
- // If at least one async loader is defined and there are no
- // (default) translations available we should try to load them.
- if (angular.equals($translationTable, {})) {
- if ($translate.use()) {
- $translate.use($translate.use());
- }
- }
-
- // Also, if there are any fallback language registered, we start
- // loading them asynchronously as soon as we can.
- if ($fallbackLanguage && $fallbackLanguage.length) {
- var processAsyncResult = function (translation) {
- translations(translation.key, translation.table);
- $rootScope.$emit('$translateChangeEnd', {language : translation.key});
- return translation;
- };
- for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
- var fallbackLanguageId = $fallbackLanguage[i];
- if ($forceAsyncReloadEnabled || !$translationTable[fallbackLanguageId]) {
- langPromises[fallbackLanguageId] = loadAsync(fallbackLanguageId).then(processAsyncResult);
- }
+ this.$get = ['$log', '$injector', '$rootScope', '$q', function ($log, $injector, $rootScope, $q) {
+
+ var Storage,
+ defaultInterpolator = $injector.get($interpolationFactory || '$translateDefaultInterpolation'),
+ pendingLoader = false,
+ interpolatorHashMap = {},
+ langPromises = {},
+ fallbackIndex,
+ startFallbackIteration;
+
+ var $translate = function $translate(translationId, interpolateParams, interpolationId, defaultTranslationText, forceLanguage) {
+ if (!$uses && $preferredLanguage) {
+ $uses = $preferredLanguage;
+ }
+ var uses = forceLanguage && forceLanguage !== $uses ? // we don't want to re-negotiate $uses
+ negotiateLocale(forceLanguage) || forceLanguage : $uses;
+
+ // Check forceLanguage is present
+ if (forceLanguage) {
+ loadTranslationsIfMissing(forceLanguage);
+ }
+
+ // Duck detection: If the first argument is an array, a bunch of translations was requested.
+ // The result is an object.
+ if (angular.isArray(translationId)) {
+ // Inspired by Q.allSettled by Kris Kowal
+ // https://github.com/kriskowal/q/blob/b0fa72980717dc202ffc3cbf03b936e10ebbb9d7/q.js#L1553-1563
+ // This transforms all promises regardless resolved or rejected
+ var translateAll = function translateAll(translationIds) {
+ var results = {}; // storing the actual results
+ var promises = []; // promises to wait for
+ // Wraps the promise a) being always resolved and b) storing the link id->value
+ var translate = function translate(translationId) {
+ var deferred = $q.defer();
+ var regardless = function regardless(value) {
+ results[translationId] = value;
+ deferred.resolve([translationId, value]);
+ };
+ // we don't care whether the promise was resolved or rejected; just store the values
+ $translate(translationId, interpolateParams, interpolationId, defaultTranslationText, forceLanguage).then(regardless, regardless);
+ return deferred.promise;
+ };
+ for (var i = 0, c = translationIds.length; i < c; i++) {
+ promises.push(translate(translationIds[i]));
+ }
+ // wait for all (including storing to results)
+ return $q.all(promises).then(function () {
+ // return the results
+ return results;
+ });
+ };
+ return translateAll(translationId);
}
- }
- } else {
- $rootScope.$emit('$translateReady', {language : $translate.use()});
- }
-
- return $translate;
- }];
-}
-
-$translate.displayName = 'displayName';
-
-/**
- * @ngdoc object
- * @name pascalprecht.translate.$translateDefaultInterpolation
- * @requires $interpolate
- *
- * @description
- * Uses angular's `$interpolate` services to interpolate strings against some values.
- *
- * Be aware to configure a proper sanitization strategy.
- *
- * See also:
- * * {@link pascalprecht.translate.$translateSanitization}
- *
- * @return {object} $translateDefaultInterpolation Interpolator service
- */
-angular.module('pascalprecht.translate').factory('$translateDefaultInterpolation', $translateDefaultInterpolation);
-
-function $translateDefaultInterpolation ($interpolate, $translateSanitization) {
-
- 'use strict';
-
- var $translateInterpolator = {},
- $locale,
- $identifier = 'default';
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateDefaultInterpolation#setLocale
- * @methodOf pascalprecht.translate.$translateDefaultInterpolation
- *
- * @description
- * Sets current locale (this is currently not use in this interpolation).
- *
- * @param {string} locale Language key or locale.
- */
- $translateInterpolator.setLocale = function (locale) {
- $locale = locale;
- };
-
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateDefaultInterpolation#getInterpolationIdentifier
- * @methodOf pascalprecht.translate.$translateDefaultInterpolation
- *
- * @description
- * Returns an identifier for this interpolation service.
- *
- * @returns {string} $identifier
- */
- $translateInterpolator.getInterpolationIdentifier = function () {
- return $identifier;
- };
- /**
- * @deprecated will be removed in 3.0
- * @see {@link pascalprecht.translate.$translateSanitization}
- */
- $translateInterpolator.useSanitizeValueStrategy = function (value) {
- $translateSanitization.useStrategy(value);
- return this;
- };
+ var deferred = $q.defer();
- /**
- * @ngdoc function
- * @name pascalprecht.translate.$translateDefaultInterpolation#interpolate
- * @methodOf pascalprecht.translate.$translateDefaultInterpolation
- *
- * @description
- * Interpolates given value agains given interpolate params using angulars
- * `$interpolate` service.
- *
- * Since AngularJS 1.5, `value` must not be a string but can be anything input.
- *
- * @param {string} value translation
- * @param {object} interpolationParams interpolation params
- * @param {string} context current context (filter, directive, service)
- * @param {string} sanitizeStrategy sanitize strategy
- * @param {string} translationId current translationId
- *
- * @returns {string} interpolated string
- */
- $translateInterpolator.interpolate = function (value, interpolationParams, context, sanitizeStrategy, translationId) { // jshint ignore:line
- interpolationParams = interpolationParams || {};
- interpolationParams = $translateSanitization.sanitize(interpolationParams, 'params', sanitizeStrategy, context);
-
- var interpolatedText;
- if (angular.isNumber(value)) {
- // numbers are safe
- interpolatedText = '' + value;
- } else if (angular.isString(value)) {
- // strings must be interpolated (that's the job here)
- interpolatedText = $interpolate(value)(interpolationParams);
- interpolatedText = $translateSanitization.sanitize(interpolatedText, 'text', sanitizeStrategy, context);
- } else {
- // neither a number or a string, cant interpolate => empty string
- interpolatedText = '';
- }
+ // trim off any whitespace
+ if (translationId) {
+ translationId = trim.apply(translationId);
+ }
- return interpolatedText;
- };
+ var promiseToWaitFor = function () {
+ var promise = $preferredLanguage ? langPromises[$preferredLanguage] : langPromises[uses];
- return $translateInterpolator;
-}
+ fallbackIndex = 0;
-$translateDefaultInterpolation.displayName = '$translateDefaultInterpolation';
+ if ($storageFactory && !promise) {
+ // looks like there's no pending promise for $preferredLanguage or
+ // $uses. Maybe there's one pending for a language that comes from
+ // storage.
+ var langKey = Storage.get($storageKey);
+ promise = langPromises[langKey];
+
+ if ($fallbackLanguage && $fallbackLanguage.length) {
+ var index = indexOf($fallbackLanguage, langKey);
+ // maybe the language from storage is also defined as fallback language
+ // we increase the fallback language index to not search in that language
+ // as fallback, since it's probably the first used language
+ // in that case the index starts after the first element
+ fallbackIndex = index === 0 ? 1 : 0;
+
+ // but we can make sure to ALWAYS fallback to preferred language at least
+ if (indexOf($fallbackLanguage, $preferredLanguage) < 0) {
+ $fallbackLanguage.push($preferredLanguage);
+ }
+ }
+ }
+ return promise;
+ }();
-angular.module('pascalprecht.translate').constant('$STORAGE_KEY', 'NG_TRANSLATE_LANG_KEY');
+ if (!promiseToWaitFor) {
+ // no promise to wait for? okay. Then there's no loader registered
+ // nor is a one pending for language that comes from storage.
+ // We can just translate.
+ determineTranslation(translationId, interpolateParams, interpolationId, defaultTranslationText, uses).then(deferred.resolve, deferred.reject);
+ } else {
+ var promiseResolved = function promiseResolved() {
+ // $uses may have changed while waiting
+ if (!forceLanguage) {
+ uses = $uses;
+ }
+ determineTranslation(translationId, interpolateParams, interpolationId, defaultTranslationText, uses).then(deferred.resolve, deferred.reject);
+ };
+ promiseResolved.displayName = 'promiseResolved';
-angular.module('pascalprecht.translate')
-/**
- * @ngdoc directive
- * @name pascalprecht.translate.directive:translate
- * @requires $interpolate,
- * @requires $compile,
- * @requires $parse,
- * @requires $rootScope
- * @restrict AE
- *
- * @description
- * Translates given translation id either through attribute or DOM content.
- * Internally it uses $translate service to translate the translation id. It possible to
- * pass an optional `translate-values` object literal as string into translation id.
- *
- * @param {string=} translate Translation id which could be either string or interpolated string.
- * @param {string=} translate-values Values to pass into translation id. Can be passed as object literal string or interpolated object.
- * @param {string=} translate-attr-ATTR translate Translation id and put it into ATTR attribute.
- * @param {string=} translate-default will be used unless translation was successful
- * @param {boolean=} translate-compile (default true if present) defines locally activation of {@link pascalprecht.translate.$translateProvider#methods_usePostCompiling}
- * @param {boolean=} translate-keep-content (default true if present) defines that in case a KEY could not be translated, that the existing content is left in the innerHTML}
- *
- * @example
-
-
-
-
-
-
TRANSLATION_ID
-
-
-
{{translationId}}
-
-
WITH_VALUES
-
-
WITH_VALUES
-
-
+ promiseToWaitFor['finally'](promiseResolved).catch(angular.noop); // we don't care about errors here, already handled
+ }
+ return deferred.promise;
+ };
-
TRANSLATION_ID
')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toBe('Hello there!');
+ var deferred = $q.defer();
- element = $compile('{{translationId}}
')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toBe('Hello there!');
+ $rootScope.$emit('$translateLoadingStart', { language: key });
+ pendingLoader = true;
- element = $compile('')($rootScope);
- $rootScope.$digest();
- expect(element.attr('title')).toBe('Hello there!');
+ var cache = loaderCache;
+ if (typeof cache === 'string') {
+ // getting on-demand instance of loader
+ cache = $injector.get(cache);
+ }
- element = $compile('')($rootScope);
- $rootScope.$digest();
- expect(element.text()).toBe('The interpolation key is camel cased: Hello');
+ var loaderOptions = angular.extend({}, $loaderOptions, {
+ key: key,
+ $http: angular.extend({}, {
+ cache: cache
+ }, $loaderOptions.$http)
});
- });
-
-
- */
-.directive('translate', translateDirective);
-function translateDirective($translate, $interpolate, $compile, $parse, $rootScope) {
-
- 'use strict';
-
- /**
- * @name trim
- * @private
- *
- * @description
- * trim polyfill
- *
- * @returns {string} The string stripped of whitespace from both ends
- */
- var trim = function() {
- return this.toString().replace(/^\s+|\s+$/g, '');
- };
- return {
- restrict: 'AE',
- scope: true,
- priority: $translate.directivePriority(),
- compile: function (tElement, tAttr) {
+ var onLoaderSuccess = function onLoaderSuccess(data) {
+ var translationTable = {};
+ $rootScope.$emit('$translateLoadingSuccess', { language: key });
- var translateValuesExist = (tAttr.translateValues) ?
- tAttr.translateValues : undefined;
+ if (angular.isArray(data)) {
+ angular.forEach(data, function (table) {
+ angular.extend(translationTable, flatObject(table));
+ });
+ } else {
+ angular.extend(translationTable, flatObject(data));
+ }
+ pendingLoader = false;
+ deferred.resolve({
+ key: key,
+ table: translationTable
+ });
+ $rootScope.$emit('$translateLoadingEnd', { language: key });
+ };
+ onLoaderSuccess.displayName = 'onLoaderSuccess';
- var translateInterpolation = (tAttr.translateInterpolation) ?
- tAttr.translateInterpolation : undefined;
+ var onLoaderError = function onLoaderError(key) {
+ $rootScope.$emit('$translateLoadingError', { language: key });
+ deferred.reject(key);
+ $rootScope.$emit('$translateLoadingEnd', { language: key });
+ };
+ onLoaderError.displayName = 'onLoaderError';
- var translateValueExist = tElement[0].outerHTML.match(/translate-value-+/i);
+ $injector.get($loaderFactory)(loaderOptions).then(onLoaderSuccess, onLoaderError);
- var interpolateRegExp = '^(.*)(' + $interpolate.startSymbol() + '.*' + $interpolate.endSymbol() + ')(.*)',
- watcherRegExp = '^(.*)' + $interpolate.startSymbol() + '(.*)' + $interpolate.endSymbol() + '(.*)';
+ return deferred.promise;
+ };
- return function linkFn(scope, iElement, iAttr) {
+ if ($storageFactory) {
+ Storage = $injector.get($storageFactory);
- scope.interpolateParams = {};
- scope.preText = '';
- scope.postText = '';
- scope.translateNamespace = getTranslateNamespace(scope);
- var translationIds = {};
+ if (!Storage.get || !Storage.put) {
+ throw new Error('Couldn\'t use storage \'' + $storageFactory + '\', missing get() or put() method!');
+ }
+ }
- var initInterpolationParams = function (interpolateParams, iAttr, tAttr) {
- // initial setup
- if (iAttr.translateValues) {
- angular.extend(interpolateParams, $parse(iAttr.translateValues)(scope.$parent));
- }
- // initially fetch all attributes if existing and fill the params
- if (translateValueExist) {
- for (var attr in tAttr) {
- if (Object.prototype.hasOwnProperty.call(iAttr, attr) && attr.substr(0, 14) === 'translateValue' && attr !== 'translateValues') {
- var attributeName = angular.lowercase(attr.substr(14, 1)) + attr.substr(15);
- interpolateParams[attributeName] = tAttr[attr];
- }
- }
- }
+ // if we have additional interpolations that were added via
+ // $translateProvider.addInterpolation(), we have to map'em
+ if ($interpolatorFactories.length) {
+ var eachInterpolationFactory = function eachInterpolationFactory(interpolatorFactory) {
+ var interpolator = $injector.get(interpolatorFactory);
+ // setting initial locale for each interpolation service
+ interpolator.setLocale($preferredLanguage || $uses);
+ // make'em recognizable through id
+ interpolatorHashMap[interpolator.getInterpolationIdentifier()] = interpolator;
};
+ eachInterpolationFactory.displayName = 'interpolationFactoryAdder';
- // Ensures any change of the attribute "translate" containing the id will
- // be re-stored to the scope's "translationId".
- // If the attribute has no content, the element's text value (white spaces trimmed off) will be used.
- var observeElementTranslation = function (translationId) {
+ angular.forEach($interpolatorFactories, eachInterpolationFactory);
+ }
- // Remove any old watcher
- if (angular.isFunction(observeElementTranslation._unwatchOld)) {
- observeElementTranslation._unwatchOld();
- observeElementTranslation._unwatchOld = undefined;
- }
+ /**
+ * @name getTranslationTable
+ * @private
+ *
+ * @description
+ * Returns a promise that resolves to the translation table
+ * or is rejected if an error occurred.
+ *
+ * @param langKey
+ * @returns {Q.promise}
+ */
+ var getTranslationTable = function getTranslationTable(langKey) {
+ var deferred = $q.defer();
+ if (Object.prototype.hasOwnProperty.call($translationTable, langKey)) {
+ deferred.resolve($translationTable[langKey]);
+ } else if (langPromises[langKey]) {
+ var onResolve = function onResolve(data) {
+ translations(data.key, data.table);
+ deferred.resolve(data.table);
+ };
+ onResolve.displayName = 'translationTableResolver';
+ langPromises[langKey].then(onResolve, deferred.reject);
+ } else {
+ deferred.reject();
+ }
+ return deferred.promise;
+ };
- if (angular.equals(translationId , '') || !angular.isDefined(translationId)) {
- var iElementText = trim.apply(iElement.text());
-
- // Resolve translation id by inner html if required
- var interpolateMatches = iElementText.match(interpolateRegExp);
- // Interpolate translation id if required
- if (angular.isArray(interpolateMatches)) {
- scope.preText = interpolateMatches[1];
- scope.postText = interpolateMatches[3];
- translationIds.translate = $interpolate(interpolateMatches[2])(scope.$parent);
- var watcherMatches = iElementText.match(watcherRegExp);
- if (angular.isArray(watcherMatches) && watcherMatches[2] && watcherMatches[2].length) {
- observeElementTranslation._unwatchOld = scope.$watch(watcherMatches[2], function (newValue) {
- translationIds.translate = newValue;
- updateTranslations();
- });
- }
+ /**
+ * @name getFallbackTranslation
+ * @private
+ *
+ * @description
+ * Returns a promise that will resolve to the translation
+ * or be rejected if no translation was found for the language.
+ * This function is currently only used for fallback language translation.
+ *
+ * @param langKey The language to translate to.
+ * @param translationId
+ * @param interpolateParams
+ * @param Interpolator
+ * @param sanitizeStrategy
+ * @returns {Q.promise}
+ */
+ var getFallbackTranslation = function getFallbackTranslation(langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy) {
+ var deferred = $q.defer();
+
+ var onResolve = function onResolve(translationTable) {
+ if (Object.prototype.hasOwnProperty.call(translationTable, translationId) && translationTable[translationId] !== null) {
+ Interpolator.setLocale(langKey);
+ var translation = translationTable[translationId];
+ if (translation.substr(0, 2) === '@:') {
+ getFallbackTranslation(langKey, translation.substr(2), interpolateParams, Interpolator, sanitizeStrategy).then(deferred.resolve, deferred.reject);
} else {
- // do not assigne the translation id if it is empty.
- translationIds.translate = !iElementText ? undefined : iElementText;
+ var interpolatedValue = Interpolator.interpolate(translationTable[translationId], interpolateParams, 'service', sanitizeStrategy, translationId);
+ interpolatedValue = applyPostProcessing(translationId, translationTable[translationId], interpolatedValue, interpolateParams, langKey);
+
+ deferred.resolve(interpolatedValue);
}
+ Interpolator.setLocale($uses);
} else {
- translationIds.translate = translationId;
+ deferred.reject();
}
- updateTranslations();
};
+ onResolve.displayName = 'fallbackTranslationResolver';
- var observeAttributeTranslation = function (translateAttr) {
- iAttr.$observe(translateAttr, function (translationId) {
- translationIds[translateAttr] = translationId;
- updateTranslations();
- });
- };
+ getTranslationTable(langKey).then(onResolve, deferred.reject);
+
+ return deferred.promise;
+ };
- // initial setup with values
- initInterpolationParams(scope.interpolateParams, iAttr, tAttr);
+ /**
+ * @name getFallbackTranslationInstant
+ * @private
+ *
+ * @description
+ * Returns a translation
+ * This function is currently only used for fallback language translation.
+ *
+ * @param langKey The language to translate to.
+ * @param translationId
+ * @param interpolateParams
+ * @param Interpolator
+ * @param sanitizeStrategy sanitize strategy override
+ *
+ * @returns {string} translation
+ */
+ var getFallbackTranslationInstant = function getFallbackTranslationInstant(langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy) {
+ var result,
+ translationTable = $translationTable[langKey];
- var firstAttributeChangedEvent = true;
- iAttr.$observe('translate', function (translationId) {
- if (typeof translationId === 'undefined') {
- // case of element "
xyz"
- observeElementTranslation('');
- } else {
- // case of regular attribute
- if (translationId !== '' || !firstAttributeChangedEvent) {
- translationIds.translate = translationId;
- updateTranslations();
+ if (translationTable && Object.prototype.hasOwnProperty.call(translationTable, translationId) && translationTable[translationId] !== null) {
+ Interpolator.setLocale(langKey);
+ result = Interpolator.interpolate(translationTable[translationId], interpolateParams, 'filter', sanitizeStrategy, translationId);
+ result = applyPostProcessing(translationId, translationTable[translationId], result, interpolateParams, langKey, sanitizeStrategy);
+ // workaround for TrustedValueHolderType
+ if (!angular.isString(result) && angular.isFunction(result.$$unwrapTrustedValue)) {
+ var result2 = result.$$unwrapTrustedValue();
+ if (result2.substr(0, 2) === '@:') {
+ return getFallbackTranslationInstant(langKey, result2.substr(2), interpolateParams, Interpolator, sanitizeStrategy);
}
+ } else if (result.substr(0, 2) === '@:') {
+ return getFallbackTranslationInstant(langKey, result.substr(2), interpolateParams, Interpolator, sanitizeStrategy);
}
- firstAttributeChangedEvent = false;
- });
+ Interpolator.setLocale($uses);
+ }
- for (var translateAttr in iAttr) {
- if (iAttr.hasOwnProperty(translateAttr) && translateAttr.substr(0, 13) === 'translateAttr' && translateAttr.length > 13) {
- observeAttributeTranslation(translateAttr);
- }
+ return result;
+ };
+
+ /**
+ * @name translateByHandler
+ * @private
+ *
+ * Translate by missing translation handler.
+ *
+ * @param translationId
+ * @param interpolateParams
+ * @param defaultTranslationText
+ * @param sanitizeStrategy sanitize strategy override
+ *
+ * @returns translation created by $missingTranslationHandler or translationId is $missingTranslationHandler is
+ * absent
+ */
+ var translateByHandler = function translateByHandler(translationId, interpolateParams, defaultTranslationText, sanitizeStrategy) {
+ // If we have a handler factory - we might also call it here to determine if it provides
+ // a default text for a translationid that can't be found anywhere in our tables
+ if ($missingTranslationHandlerFactory) {
+ return $injector.get($missingTranslationHandlerFactory)(translationId, $uses, interpolateParams, defaultTranslationText, sanitizeStrategy);
+ } else {
+ return translationId;
}
+ };
- iAttr.$observe('translateDefault', function (value) {
- scope.defaultText = value;
- updateTranslations();
- });
+ /**
+ * @name resolveForFallbackLanguage
+ * @private
+ *
+ * Recursive helper function for fallbackTranslation that will sequentially look
+ * for a translation in the fallbackLanguages starting with fallbackLanguageIndex.
+ *
+ * @param fallbackLanguageIndex
+ * @param translationId
+ * @param interpolateParams
+ * @param Interpolator
+ * @param defaultTranslationText
+ * @param sanitizeStrategy
+ * @returns {Q.promise} Promise that will resolve to the translation.
+ */
+ var resolveForFallbackLanguage = function resolveForFallbackLanguage(fallbackLanguageIndex, translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy) {
+ var deferred = $q.defer();
- if (translateValuesExist) {
- iAttr.$observe('translateValues', function (interpolateParams) {
- if (interpolateParams) {
- scope.$parent.$watch(function () {
- angular.extend(scope.interpolateParams, $parse(interpolateParams)(scope.$parent));
- });
- }
+ if (fallbackLanguageIndex < $fallbackLanguage.length) {
+ var langKey = $fallbackLanguage[fallbackLanguageIndex];
+ getFallbackTranslation(langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy).then(function (data) {
+ deferred.resolve(data);
+ }, function () {
+ // Look in the next fallback language for a translation.
+ // It delays the resolving by passing another promise to resolve.
+ return resolveForFallbackLanguage(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy).then(deferred.resolve, deferred.reject);
});
- }
+ } else {
+ // No translation found in any fallback language
+ // if a default translation text is set in the directive, then return this as a result
+ if (defaultTranslationText) {
+ deferred.resolve(defaultTranslationText);
+ } else {
+ var missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, defaultTranslationText);
- if (translateValueExist) {
- var observeValueAttribute = function (attrName) {
- iAttr.$observe(attrName, function (value) {
- var attributeName = angular.lowercase(attrName.substr(14, 1)) + attrName.substr(15);
- scope.interpolateParams[attributeName] = value;
- });
- };
- for (var attr in iAttr) {
- if (Object.prototype.hasOwnProperty.call(iAttr, attr) && attr.substr(0, 14) === 'translateValue' && attr !== 'translateValues') {
- observeValueAttribute(attr);
+ // if no default translation is set and an error handler is defined, send it to the handler
+ // and then return the result if it isn't undefined
+ if ($missingTranslationHandlerFactory && missingTranslationHandlerTranslation) {
+ deferred.resolve(missingTranslationHandlerTranslation);
+ } else {
+ deferred.reject(applyNotFoundIndicators(translationId));
}
}
}
+ return deferred.promise;
+ };
- // Master update function
- var updateTranslations = function () {
- for (var key in translationIds) {
- if (translationIds.hasOwnProperty(key) && translationIds[key] !== undefined) {
- updateTranslation(key, translationIds[key], scope, scope.interpolateParams, scope.defaultText, scope.translateNamespace);
- }
- }
- };
+ /**
+ * @name resolveForFallbackLanguageInstant
+ * @private
+ *
+ * Recursive helper function for fallbackTranslation that will sequentially look
+ * for a translation in the fallbackLanguages starting with fallbackLanguageIndex.
+ *
+ * @param fallbackLanguageIndex
+ * @param translationId
+ * @param interpolateParams
+ * @param Interpolator
+ * @param sanitizeStrategy
+ * @returns {string} translation
+ */
+ var resolveForFallbackLanguageInstant = function resolveForFallbackLanguageInstant(fallbackLanguageIndex, translationId, interpolateParams, Interpolator, sanitizeStrategy) {
+ var result;
+
+ if (fallbackLanguageIndex < $fallbackLanguage.length) {
+ var langKey = $fallbackLanguage[fallbackLanguageIndex];
+ result = getFallbackTranslationInstant(langKey, translationId, interpolateParams, Interpolator, sanitizeStrategy);
+ if (!result && result !== '') {
+ result = resolveForFallbackLanguageInstant(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator);
+ }
+ }
+ return result;
+ };
- // Put translation processing function outside loop
- var updateTranslation = function(translateAttr, translationId, scope, interpolateParams, defaultTranslationText, translateNamespace) {
- if (translationId) {
- // if translation id starts with '.' and translateNamespace given, prepend namespace
- if (translateNamespace && translationId.charAt(0) === '.') {
- translationId = translateNamespace + translationId;
- }
+ /**
+ * Translates with the usage of the fallback languages.
+ *
+ * @param translationId
+ * @param interpolateParams
+ * @param Interpolator
+ * @param defaultTranslationText
+ * @param sanitizeStrategy
+ * @returns {Q.promise} Promise, that resolves to the translation.
+ */
+ var fallbackTranslation = function fallbackTranslation(translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy) {
+ // Start with the fallbackLanguage with index 0
+ return resolveForFallbackLanguage(startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex, translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy);
+ };
- $translate(translationId, interpolateParams, translateInterpolation, defaultTranslationText, scope.translateLanguage)
- .then(function (translation) {
- applyTranslation(translation, scope, true, translateAttr);
- }, function (translationId) {
- applyTranslation(translationId, scope, false, translateAttr);
- });
+ /**
+ * Translates with the usage of the fallback languages.
+ *
+ * @param translationId
+ * @param interpolateParams
+ * @param Interpolator
+ * @param sanitizeStrategy
+ * @returns {String} translation
+ */
+ var fallbackTranslationInstant = function fallbackTranslationInstant(translationId, interpolateParams, Interpolator, sanitizeStrategy) {
+ // Start with the fallbackLanguage with index 0
+ return resolveForFallbackLanguageInstant(startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex, translationId, interpolateParams, Interpolator, sanitizeStrategy);
+ };
+
+ var determineTranslation = function determineTranslation(translationId, interpolateParams, interpolationId, defaultTranslationText, uses, sanitizeStrategy) {
+
+ var deferred = $q.defer();
+
+ var table = uses ? $translationTable[uses] : $translationTable,
+ Interpolator = interpolationId ? interpolatorHashMap[interpolationId] : defaultInterpolator;
+
+ // if the translation id exists, we can just interpolate it
+ if (table && Object.prototype.hasOwnProperty.call(table, translationId) && table[translationId] !== null) {
+ var translation = table[translationId];
+
+ // If using link, rerun $translate with linked translationId and return it
+ if (translation.substr(0, 2) === '@:') {
+
+ $translate(translation.substr(2), interpolateParams, interpolationId, defaultTranslationText, uses).then(deferred.resolve, deferred.reject);
} else {
- // as an empty string cannot be translated, we can solve this using successful=false
- applyTranslation(translationId, scope, false, translateAttr);
+ //
+ var resolvedTranslation = Interpolator.interpolate(translation, interpolateParams, 'service', sanitizeStrategy, translationId);
+ resolvedTranslation = applyPostProcessing(translationId, translation, resolvedTranslation, interpolateParams, uses);
+ deferred.resolve(resolvedTranslation);
}
- };
-
- var applyTranslation = function (value, scope, successful, translateAttr) {
- if (!successful) {
- if (typeof scope.defaultText !== 'undefined') {
- value = scope.defaultText;
- }
+ } else {
+ var missingTranslationHandlerTranslation;
+ // for logging purposes only (as in $translateMissingTranslationHandlerLog), value is not returned to promise
+ if ($missingTranslationHandlerFactory && !pendingLoader) {
+ missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, defaultTranslationText);
}
- if (translateAttr === 'translate') {
- // default translate into innerHTML
- if (successful || (!successful && !$translate.isKeepContent() && typeof iAttr.translateKeepContent === 'undefined')) {
- iElement.empty().append(scope.preText + value + scope.postText);
- }
- var globallyEnabled = $translate.isPostCompilingEnabled();
- var locallyDefined = typeof tAttr.translateCompile !== 'undefined';
- var locallyEnabled = locallyDefined && tAttr.translateCompile !== 'false';
- if ((globallyEnabled && !locallyDefined) || locallyEnabled) {
- $compile(iElement.contents())(scope);
+
+ // since we couldn't translate the inital requested translation id,
+ // we try it now with one or more fallback languages, if fallback language(s) is
+ // configured.
+ if (uses && $fallbackLanguage && $fallbackLanguage.length) {
+ fallbackTranslation(translationId, interpolateParams, Interpolator, defaultTranslationText, sanitizeStrategy).then(function (translation) {
+ deferred.resolve(translation);
+ }, function (_translationId) {
+ deferred.reject(applyNotFoundIndicators(_translationId));
+ });
+ } else if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
+ // looks like the requested translation id doesn't exists.
+ // Now, if there is a registered handler for missing translations and no
+ // asyncLoader is pending, we execute the handler
+ if (defaultTranslationText) {
+ deferred.resolve(defaultTranslationText);
+ } else {
+ deferred.resolve(missingTranslationHandlerTranslation);
}
} else {
- // translate attribute
- var attributeName = iAttr.$attr[translateAttr];
- if (attributeName.substr(0, 5) === 'data-') {
- // ensure html5 data prefix is stripped
- attributeName = attributeName.substr(5);
+ if (defaultTranslationText) {
+ deferred.resolve(defaultTranslationText);
+ } else {
+ deferred.reject(applyNotFoundIndicators(translationId));
}
- attributeName = attributeName.substr(15);
- iElement.attr(attributeName, value);
}
- };
-
- if (translateValuesExist || translateValueExist || iAttr.translateDefault) {
- scope.$watch('interpolateParams', updateTranslations, true);
}
+ return deferred.promise;
+ };
- // Replaced watcher on translateLanguage with event listener
- scope.$on('translateLanguageChanged', updateTranslations);
+ var determineTranslationInstant = function determineTranslationInstant(translationId, interpolateParams, interpolationId, uses, sanitizeStrategy) {
- // Ensures the text will be refreshed after the current language was changed
- // w/ $translate.use(...)
- var unbind = $rootScope.$on('$translateChangeSuccess', updateTranslations);
+ var result,
+ table = uses ? $translationTable[uses] : $translationTable,
+ Interpolator = defaultInterpolator;
- // ensure translation will be looked up at least one
- if (iElement.text().length) {
- if (iAttr.translate) {
- observeElementTranslation(iAttr.translate);
- } else {
- observeElementTranslation('');
- }
- } else if (iAttr.translate) {
- // ensure attribute will be not skipped
- observeElementTranslation(iAttr.translate);
+ // if the interpolation id exists use custom interpolator
+ if (interpolatorHashMap && Object.prototype.hasOwnProperty.call(interpolatorHashMap, interpolationId)) {
+ Interpolator = interpolatorHashMap[interpolationId];
}
- updateTranslations();
- scope.$on('$destroy', unbind);
- };
- }
- };
-}
-
-/**
- * Returns the scope's namespace.
- * @private
- * @param scope
- * @returns {string}
- */
-function getTranslateNamespace(scope) {
- 'use strict';
- if (scope.translateNamespace) {
- return scope.translateNamespace;
- }
- if (scope.$parent) {
- return getTranslateNamespace(scope.$parent);
- }
-}
-
-translateDirective.displayName = 'translateDirective';
-angular.module('pascalprecht.translate')
-/**
- * @ngdoc directive
- * @name pascalprecht.translate.directive:translate-attr
- * @restrict A
- *
- * @description
- * Translates attributes like translate-attr-ATTR, but with an object like ng-class.
- * Internally it uses `translate` service to translate translation id. It possible to
- * pass an optional `translate-values` object literal as string into translation id.
- *
- * @param {string=} translate-attr Object literal mapping attributes to translation ids.
- * @param {string=} translate-values Values to pass into the translation ids. Can be passed as object literal string.
- *
- * @example
-
-
-
+ // if the translation id exists, we can just interpolate it
+ if (table && Object.prototype.hasOwnProperty.call(table, translationId) && table[translationId] !== null) {
+ var translation = table[translationId];
-
+ // If using link, rerun $translate with linked translationId and return it
+ if (translation.substr(0, 2) === '@:') {
+ result = determineTranslationInstant(translation.substr(2), interpolateParams, interpolationId, uses, sanitizeStrategy);
+ } else {
+ result = Interpolator.interpolate(translation, interpolateParams, 'filter', sanitizeStrategy, translationId);
+ result = applyPostProcessing(translationId, translation, result, interpolateParams, uses, sanitizeStrategy);
+ }
+ } else {
+ var missingTranslationHandlerTranslation;
+ // for logging purposes only (as in $translateMissingTranslationHandlerLog), value is not returned to promise
+ if ($missingTranslationHandlerFactory && !pendingLoader) {
+ missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, sanitizeStrategy);
+ }
-
-
-
- angular.module('ngView', ['pascalprecht.translate'])
+ // since we couldn't translate the inital requested translation id,
+ // we try it now with one or more fallback languages, if fallback language(s) is
+ // configured.
+ if (uses && $fallbackLanguage && $fallbackLanguage.length) {
+ fallbackIndex = 0;
+ result = fallbackTranslationInstant(translationId, interpolateParams, Interpolator, sanitizeStrategy);
+ } else if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
+ // looks like the requested translation id doesn't exists.
+ // Now, if there is a registered handler for missing translations and no
+ // asyncLoader is pending, we execute the handler
+ result = missingTranslationHandlerTranslation;
+ } else {
+ result = applyNotFoundIndicators(translationId);
+ }
+ }
- .config(function ($translateProvider) {
+ return result;
+ };
- $translateProvider.translations('en',{
- 'TRANSLATION_ID': 'Hello there!',
- 'WITH_VALUES': 'The following value is dynamic: {{value}}',
- }).preferredLanguage('en');
+ var clearNextLangAndPromise = function clearNextLangAndPromise(key) {
+ if ($nextLang === key) {
+ $nextLang = undefined;
+ }
+ langPromises[key] = undefined;
+ };
- });
+ var applyPostProcessing = function applyPostProcessing(translationId, translation, resolvedTranslation, interpolateParams, uses, sanitizeStrategy) {
+ var fn = postProcessFn;
- angular.module('ngView').controller('TranslateCtrl', function ($scope) {
- $scope.translationId = 'TRANSLATION_ID';
+ if (fn) {
- $scope.values = {
- value: 78
- };
- });
-
-
- it('should translate', function () {
- inject(function ($rootScope, $compile) {
- $rootScope.translationId = 'TRANSLATION_ID';
+ if (typeof fn === 'string') {
+ // getting on-demand instance
+ fn = $injector.get(fn);
+ }
+ if (fn) {
+ return fn(translationId, translation, resolvedTranslation, interpolateParams, uses, sanitizeStrategy);
+ }
+ }
- element = $compile('')($rootScope);
- $rootScope.$digest();
- expect(element.attr('placeholder)).toBe('Hello there!');
- expect(element.attr('title)).toBe('The following value is dynamic: 5');
- });
- });
-
-
- */
-.directive('translateAttr', translateAttrDirective);
-function translateAttrDirective($translate, $rootScope) {
+ return resolvedTranslation;
+ };
- 'use strict';
+ var loadTranslationsIfMissing = function loadTranslationsIfMissing(key) {
+ if (!$translationTable[key] && $loaderFactory && !langPromises[key]) {
+ langPromises[key] = loadAsync(key).then(function (translation) {
+ translations(translation.key, translation.table);
+ return translation;
+ });
+ }
+ };
- return {
- restrict: 'A',
- priority: $translate.directivePriority(),
- link: function linkFn(scope, element, attr) {
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#preferredLanguage
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the language key for the preferred language.
+ *
+ * @param {string} langKey language String or Array to be used as preferredLanguage (changing at runtime)
+ *
+ * @return {string} preferred language key
+ */
+ $translate.preferredLanguage = function (langKey) {
+ if (langKey) {
+ setupPreferredLanguage(langKey);
+ }
+ return $preferredLanguage;
+ };
- var translateAttr,
- translateValues,
- previousAttributes = {};
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#cloakClassName
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the configured class name for `translate-cloak` directive.
+ *
+ * @return {string} cloakClassName
+ */
+ $translate.cloakClassName = function () {
+ return $cloakClassName;
+ };
- // Main update translations function
- var updateTranslations = function () {
- angular.forEach(translateAttr, function (translationId, attributeName) {
- if (!translationId) {
- return;
- }
- previousAttributes[attributeName] = true;
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#nestedObjectDelimeter
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the configured delimiter for nested namespaces.
+ *
+ * @return {string} nestedObjectDelimeter
+ */
+ $translate.nestedObjectDelimeter = function () {
+ return $nestedObjectDelimeter;
+ };
- // if translation id starts with '.' and translateNamespace given, prepend namespace
- if (scope.translateNamespace && translationId.charAt(0) === '.') {
- translationId = scope.translateNamespace + translationId;
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#fallbackLanguage
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the language key for the fallback languages or sets a new fallback stack.
+ *
+ * @param {string=} langKey language String or Array of fallback languages to be used (to change stack at runtime)
+ *
+ * @return {string||array} fallback language key
+ */
+ $translate.fallbackLanguage = function (langKey) {
+ if (langKey !== undefined && langKey !== null) {
+ fallbackStack(langKey);
+
+ // as we might have an async loader initiated and a new translation language might have been defined
+ // we need to add the promise to the stack also. So - iterate.
+ if ($loaderFactory) {
+ if ($fallbackLanguage && $fallbackLanguage.length) {
+ for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
+ if (!langPromises[$fallbackLanguage[i]]) {
+ langPromises[$fallbackLanguage[i]] = loadAsync($fallbackLanguage[i]);
+ }
+ }
+ }
}
- $translate(translationId, translateValues, attr.translateInterpolation, undefined, scope.translateLanguage)
- .then(function (translation) {
- element.attr(attributeName, translation);
- }, function (translationId) {
- element.attr(attributeName, translationId);
- });
- });
+ $translate.use($translate.use());
+ }
+ if ($fallbackWasString) {
+ return $fallbackLanguage[0];
+ } else {
+ return $fallbackLanguage;
+ }
+ };
- // Removing unused attributes that were previously used
- angular.forEach(previousAttributes, function (flag, attributeName) {
- if (!translateAttr[attributeName]) {
- element.removeAttr(attributeName);
- delete previousAttributes[attributeName];
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#useFallbackLanguage
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Sets the first key of the fallback language stack to be used for translation.
+ * Therefore all languages in the fallback array BEFORE this key will be skipped!
+ *
+ * @param {string=} langKey Contains the langKey the iteration shall start with. Set to false if you want to
+ * get back to the whole stack
+ */
+ $translate.useFallbackLanguage = function (langKey) {
+ if (langKey !== undefined && langKey !== null) {
+ if (!langKey) {
+ startFallbackIteration = 0;
+ } else {
+ var langKeyPosition = indexOf($fallbackLanguage, langKey);
+ if (langKeyPosition > -1) {
+ startFallbackIteration = langKeyPosition;
+ }
}
- });
+ }
};
- // Watch for attribute changes
- watchAttribute(
- scope,
- attr.translateAttr,
- function (newValue) { translateAttr = newValue; },
- updateTranslations
- );
- // Watch for value changes
- watchAttribute(
- scope,
- attr.translateValues,
- function (newValue) { translateValues = newValue; },
- updateTranslations
- );
-
- if (attr.translateValues) {
- scope.$watch(attr.translateValues, updateTranslations, true);
- }
-
- // Replaced watcher on translateLanguage with event listener
- scope.$on('translateLanguageChanged', updateTranslations);
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#proposedLanguage
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the language key of language that is currently loaded asynchronously.
+ *
+ * @return {string} language key
+ */
+ $translate.proposedLanguage = function () {
+ return $nextLang;
+ };
- // Ensures the text will be refreshed after the current language was changed
- // w/ $translate.use(...)
- var unbind = $rootScope.$on('$translateChangeSuccess', updateTranslations);
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#storage
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns registered storage.
+ *
+ * @return {object} Storage
+ */
+ $translate.storage = function () {
+ return Storage;
+ };
- updateTranslations();
- scope.$on('$destroy', unbind);
- }
- };
-}
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#negotiateLocale
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns a language key based on available languages and language aliases. If a
+ * language key cannot be resolved, returns undefined.
+ *
+ * If no or a falsy key is given, returns undefined.
+ *
+ * @param {string} [key] Language key
+ * @return {string|undefined} Language key or undefined if no language key is found.
+ */
+ $translate.negotiateLocale = negotiateLocale;
-function watchAttribute(scope, attribute, valueCallback, changeCallback) {
- 'use strict';
- if (!attribute) {
- return;
- }
- if (attribute.substr(0, 2) === '::') {
- attribute = attribute.substr(2);
- } else {
- scope.$watch(attribute, function(newValue) {
- valueCallback(newValue);
- changeCallback();
- }, true);
- }
- valueCallback(scope.$eval(attribute));
-}
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#use
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Tells angular-translate which language to use by given language key. This method is
+ * used to change language at runtime. It also takes care of storing the language
+ * key in a configured store to let your app remember the choosed language.
+ *
+ * When trying to 'use' a language which isn't available it tries to load it
+ * asynchronously with registered loaders.
+ *
+ * Returns promise object with loaded language file data or string of the currently used language.
+ *
+ * If no or a falsy key is given it returns the currently used language key.
+ * The returned string will be ```undefined``` if setting up $translate hasn't finished.
+ * @example
+ * $translate.use("en_US").then(function(data){
+ * $scope.text = $translate("HELLO");
+ * });
+ *
+ * @param {string} [key] Language key
+ * @return {object|string} Promise with loaded language data or the language key if a falsy param was given.
+ */
+ $translate.use = function (key) {
+ if (!key) {
+ return $uses;
+ }
-translateAttrDirective.displayName = 'translateAttrDirective';
+ var deferred = $q.defer();
+ deferred.promise.then(null, angular.noop); // AJS "Possibly unhandled rejection"
-angular.module('pascalprecht.translate')
-/**
- * @ngdoc directive
- * @name pascalprecht.translate.directive:translateCloak
- * @requires $translate
- * @restrict A
- *
- * $description
- * Adds a `translate-cloak` class name to the given element where this directive
- * is applied initially and removes it, once a loader has finished loading.
- *
- * This directive can be used to prevent initial flickering when loading translation
- * data asynchronously.
- *
- * The class name is defined in
- * {@link pascalprecht.translate.$translateProvider#cloakClassName $translate.cloakClassName()}.
- *
- * @param {string=} translate-cloak If a translationId is provided, it will be used for showing
- * or hiding the cloak. Basically it relies on the translation
- * resolve.
- */
-.directive('translateCloak', translateCloakDirective);
+ $rootScope.$emit('$translateChangeStart', { language: key });
-function translateCloakDirective($translate, $rootScope) {
+ // Try to get the aliased language key
+ var aliasedKey = negotiateLocale(key);
+ // Ensure only registered language keys will be loaded
+ if ($availableLanguageKeys.length > 0 && !aliasedKey) {
+ return $q.reject(key);
+ }
- 'use strict';
+ if (aliasedKey) {
+ key = aliasedKey;
+ }
- return {
- compile : function (tElement) {
- var applyCloak = function (element) {
- element.addClass($translate.cloakClassName());
- },
- removeCloak = function (element) {
- element.removeClass($translate.cloakClassName());
- };
- applyCloak(tElement);
-
- return function linkFn(scope, iElement, iAttr) {
- //Create bound functions that incorporate the active DOM element.
- var iRemoveCloak = removeCloak.bind(this, iElement), iApplyCloak = applyCloak.bind(this, iElement);
- if (iAttr.translateCloak && iAttr.translateCloak.length) {
- // Register a watcher for the defined translation allowing a fine tuned cloak
- iAttr.$observe('translateCloak', function (translationId) {
- $translate(translationId).then(iRemoveCloak, iApplyCloak);
+ // if there isn't a translation table for the language we've requested,
+ // we load it asynchronously
+ $nextLang = key;
+ if (($forceAsyncReloadEnabled || !$translationTable[key]) && $loaderFactory && !langPromises[key]) {
+ langPromises[key] = loadAsync(key).then(function (translation) {
+ translations(translation.key, translation.table);
+ deferred.resolve(translation.key);
+ if ($nextLang === key) {
+ useLanguage(translation.key);
+ }
+ return translation;
+ }, function (key) {
+ $rootScope.$emit('$translateChangeError', { language: key });
+ deferred.reject(key);
+ $rootScope.$emit('$translateChangeEnd', { language: key });
+ return $q.reject(key);
});
- $rootScope.$on('$translateChangeSuccess', function () {
- $translate(iAttr.translateCloak).then(iRemoveCloak, iApplyCloak);
+ langPromises[key]['finally'](function () {
+ clearNextLangAndPromise(key);
+ }).catch(angular.noop); // we don't care about errors (clearing)
+ } else if (langPromises[key]) {
+ // we are already loading this asynchronously
+ // resolve our new deferred when the old langPromise is resolved
+ langPromises[key].then(function (translation) {
+ if ($nextLang === translation.key) {
+ useLanguage(translation.key);
+ }
+ deferred.resolve(translation.key);
+ return translation;
+ }, function (key) {
+ // find first available fallback language if that request has failed
+ if (!$uses && $fallbackLanguage && $fallbackLanguage.length > 0 && $fallbackLanguage[0] !== key) {
+ return $translate.use($fallbackLanguage[0]).then(deferred.resolve, deferred.reject);
+ } else {
+ return deferred.reject(key);
+ }
});
} else {
- $translate.onReady(iRemoveCloak);
+ deferred.resolve(key);
+ useLanguage(key);
}
- };
- }
- };
-}
-
-translateCloakDirective.displayName = 'translateCloakDirective';
-angular.module('pascalprecht.translate')
-/**
- * @ngdoc directive
- * @name pascalprecht.translate.directive:translateNamespace
- * @restrict A
- *
- * @description
- * Translates given translation id either through attribute or DOM content.
- * Internally it uses `translate` filter to translate translation id. It possible to
- * pass an optional `translate-values` object literal as string into translation id.
- *
- * @param {string=} translate namespace name which could be either string or interpolated string.
- *
- * @example
-
-
-
+ return deferred.promise;
+ };
-
-
.HEADERS.TITLE
- .HEADERS.WELCOME
-
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#resolveClientLocale
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * This returns the current browser/client's language key. The result is processed with the configured uniform tag resolver.
+ *
+ * @returns {string} the current client/browser language key
+ */
+ $translate.resolveClientLocale = function () {
+ return getLocale();
+ };
-
-
.TITLE
- .WELCOME
-
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#storageKey
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the key for the storage.
+ *
+ * @return {string} storage key
+ */
+ $translate.storageKey = function () {
+ return storageKey();
+ };
-
- */
-.directive('translateNamespace', translateNamespaceDirective);
+ $rootScope.$emit('$translateRefreshStart', { language: langKey });
-function translateNamespaceDirective() {
+ var deferred = $q.defer(),
+ updatedLanguages = {};
- 'use strict';
+ //private helper
+ function loadNewData(languageKey) {
+ var promise = loadAsync(languageKey);
+ //update the load promise cache for this language
+ langPromises[languageKey] = promise;
+ //register a data handler for the promise
+ promise.then(function (data) {
+ //clear the cache for this language
+ $translationTable[languageKey] = {};
+ //add the new data for this language
+ translations(languageKey, data.table);
+ //track that we updated this language
+ updatedLanguages[languageKey] = true;
+ },
+ //handle rejection to appease the $q validation
+ angular.noop);
+ return promise;
+ }
- return {
- restrict: 'A',
- scope: true,
- compile: function () {
- return {
- pre: function (scope, iElement, iAttrs) {
- scope.translateNamespace = getTranslateNamespace(scope);
+ //set up post-processing
+ deferred.promise.then(function () {
+ for (var key in $translationTable) {
+ if ($translationTable.hasOwnProperty(key)) {
+ //delete cache entries that were not updated
+ if (!(key in updatedLanguages)) {
+ delete $translationTable[key];
+ }
+ }
+ }
+ if ($uses) {
+ useLanguage($uses);
+ }
+ },
+ //handle rejection to appease the $q validation
+ angular.noop).finally(function () {
+ $rootScope.$emit('$translateRefreshEnd', { language: langKey });
+ });
- if (scope.translateNamespace && iAttrs.translateNamespace.charAt(0) === '.') {
- scope.translateNamespace += iAttrs.translateNamespace;
- } else {
- scope.translateNamespace = iAttrs.translateNamespace;
+ if (!langKey) {
+ // if there's no language key specified we refresh ALL THE THINGS!
+ var languagesToReload = $fallbackLanguage && $fallbackLanguage.slice() || [];
+ if ($uses && languagesToReload.indexOf($uses) === -1) {
+ languagesToReload.push($uses);
}
+ $q.all(languagesToReload.map(loadNewData)).then(deferred.resolve, deferred.reject);
+ } else if ($translationTable[langKey]) {
+ //just refresh the specified language cache
+ loadNewData(langKey).then(deferred.resolve, deferred.reject);
+ } else {
+ deferred.reject();
}
- };
- }
- };
-}
-/**
- * Returns the scope's namespace.
- * @private
- * @param scope
- * @returns {string}
- */
-function getTranslateNamespace(scope) {
- 'use strict';
- if (scope.translateNamespace) {
- return scope.translateNamespace;
- }
- if (scope.$parent) {
- return getTranslateNamespace(scope.$parent);
- }
-}
+ return deferred.promise;
+ };
-translateNamespaceDirective.displayName = 'translateNamespaceDirective';
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#instant
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns a translation instantly from the internal state of loaded translation. All rules
+ * regarding the current language, the preferred language of even fallback languages will be
+ * used except any promise handling. If a language was not found, an asynchronous loading
+ * will be invoked in the background.
+ *
+ * @param {string|array} translationId A token which represents a translation id
+ * This can be optionally an array of translation ids which
+ * results that the function's promise returns an object where
+ * each key is the translation id and the value the translation.
+ * @param {object} interpolateParams Params
+ * @param {string} interpolationId The id of the interpolation to use
+ * @param {string} forceLanguage A language to be used instead of the current language
+ * @param {string} sanitizeStrategy force sanitize strategy for this call instead of using the configured one
+ *
+ * @return {string|object} translation
+ */
+ $translate.instant = function (translationId, interpolateParams, interpolationId, forceLanguage, sanitizeStrategy) {
-angular.module('pascalprecht.translate')
-/**
- * @ngdoc directive
- * @name pascalprecht.translate.directive:translateLanguage
- * @restrict A
- *
- * @description
- * Forces the language to the directives in the underlying scope.
- *
- * @param {string=} translate language that will be negotiated.
- *
- * @example
-
-
-
+ // we don't want to re-negotiate $uses
+ var uses = forceLanguage && forceLanguage !== $uses ? // we don't want to re-negotiate $uses
+ negotiateLocale(forceLanguage) || forceLanguage : $uses;
-
-
HELLO
-
+ // Detect undefined and null values to shorten the execution and prevent exceptions
+ if (translationId === null || angular.isUndefined(translationId)) {
+ return translationId;
+ }
-
-
HELLO
-
+ // Check forceLanguage is present
+ if (forceLanguage) {
+ loadTranslationsIfMissing(forceLanguage);
+ }
-
- */
-.directive('translateLanguage', translateLanguageDirective);
+ if (!result && result !== '') {
+ if ($notFoundIndicatorLeft || $notFoundIndicatorRight) {
+ result = applyNotFoundIndicators(translationId);
+ } else {
+ // Return translation of default interpolator if not found anything.
+ result = defaultInterpolator.interpolate(translationId, interpolateParams, 'filter', sanitizeStrategy);
+
+ // looks like the requested translation id doesn't exists.
+ // Now, if there is a registered handler for missing translations and no
+ // asyncLoader is pending, we execute the handler
+ var missingTranslationHandlerTranslation;
+ if ($missingTranslationHandlerFactory && !pendingLoader) {
+ missingTranslationHandlerTranslation = translateByHandler(translationId, interpolateParams, sanitizeStrategy);
+ }
-function translateLanguageDirective() {
+ if ($missingTranslationHandlerFactory && !pendingLoader && missingTranslationHandlerTranslation) {
+ result = missingTranslationHandlerTranslation;
+ }
+ }
+ }
- 'use strict';
+ return result;
+ };
- return {
- restrict: 'A',
- scope: true,
- compile: function () {
- return function linkFn(scope, iElement, iAttrs) {
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#versionInfo
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the current version information for the angular-translate library
+ *
+ * @return {string} angular-translate version
+ */
+ $translate.versionInfo = function () {
+ return version;
+ };
- iAttrs.$observe('translateLanguage', function (newTranslateLanguage) {
- scope.translateLanguage = newTranslateLanguage;
- });
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#loaderCache
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns the defined loaderCache.
+ *
+ * @return {boolean|string|object} current value of loaderCache
+ */
+ $translate.loaderCache = function () {
+ return loaderCache;
+ };
- scope.$watch('translateLanguage', function(){
- scope.$broadcast('translateLanguageChanged');
- });
+ // internal purpose only
+ $translate.directivePriority = function () {
+ return directivePriority;
};
- }
- };
-}
-translateLanguageDirective.displayName = 'translateLanguageDirective';
+ // internal purpose only
+ $translate.statefulFilter = function () {
+ return statefulFilter;
+ };
-angular.module('pascalprecht.translate')
-/**
- * @ngdoc filter
- * @name pascalprecht.translate.filter:translate
- * @requires $parse
- * @requires pascalprecht.translate.$translate
- * @function
- *
- * @description
- * Uses `$translate` service to translate contents. Accepts interpolate parameters
- * to pass dynamized values though translation.
- *
- * @param {string} translationId A translation id to be translated.
- * @param {*=} interpolateParams Optional object literal (as hash or string) to pass values into translation.
- *
- * @returns {string} Translated text.
- *
- * @example
-
-
-
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translate#isReady
+ * @methodOf pascalprecht.translate.$translate
+ *
+ * @description
+ * Returns whether the service is "ready" to translate (i.e. loading 1st language).
+ *
+ * See also {@link pascalprecht.translate.$translate#methods_onReady onReady()}.
+ *
+ * @return {boolean} current value of ready
+ */
+ $translate.isReady = function () {
+ return $isReady;
+ };
-
{{ 'TRANSLATION_ID' | translate }}
-
{{ translationId | translate }}
-
{{ 'WITH_VALUES' | translate:'{value: 5}' }}
-
{{ 'WITH_VALUES' | translate:values }}
+ var $onReadyDeferred = $q.defer();
+ $onReadyDeferred.promise.then(function () {
+ $isReady = true;
+ });
-
- */
-.filter('translate', translateFilterFactory);
-function translateFilterFactory($parse, $translate) {
-
- 'use strict';
+ if ($loaderFactory) {
- var translateFilter = function (translationId, interpolateParams, interpolation, forceLanguage) {
- if (!angular.isObject(interpolateParams)) {
- var ctx = this || {
- '__SCOPE_IS_NOT_AVAILABLE': 'More info at https://github.com/angular/angular.js/commit/8863b9d04c722b278fa93c5d66ad1e578ad6eb1f'
- };
- interpolateParams = $parse(interpolateParams)(ctx);
- }
+ // If at least one async loader is defined and there are no
+ // (default) translations available we should try to load them.
+ if (angular.equals($translationTable, {})) {
+ if ($translate.use()) {
+ $translate.use($translate.use());
+ }
+ }
- return $translate.instant(translationId, interpolateParams, interpolation, forceLanguage);
- };
+ // Also, if there are any fallback language registered, we start
+ // loading them asynchronously as soon as we can.
+ if ($fallbackLanguage && $fallbackLanguage.length) {
+ var processAsyncResult = function processAsyncResult(translation) {
+ translations(translation.key, translation.table);
+ $rootScope.$emit('$translateChangeEnd', { language: translation.key });
+ return translation;
+ };
+ for (var i = 0, len = $fallbackLanguage.length; i < len; i++) {
+ var fallbackLanguageId = $fallbackLanguage[i];
+ if ($forceAsyncReloadEnabled || !$translationTable[fallbackLanguageId]) {
+ langPromises[fallbackLanguageId] = loadAsync(fallbackLanguageId).then(processAsyncResult);
+ }
+ }
+ }
+ } else {
+ $rootScope.$emit('$translateReady', { language: $translate.use() });
+ }
- if ($translate.statefulFilter()) {
- translateFilter.$stateful = true;
+ return $translate;
+ }];
}
- return translateFilter;
-}
+ $translate.displayName = 'displayName';
-translateFilterFactory.displayName = 'translateFilterFactory';
+ /**
+ * @ngdoc object
+ * @name pascalprecht.translate.$translateDefaultInterpolation
+ * @requires $interpolate
+ *
+ * @description
+ * Uses angular's `$interpolate` services to interpolate strings against some values.
+ *
+ * Be aware to configure a proper sanitization strategy.
+ *
+ * See also:
+ * * {@link pascalprecht.translate.$translateSanitization}
+ *
+ * @return {object} $translateDefaultInterpolation Interpolator service
+ */
+ angular.module('pascalprecht.translate').factory('$translateDefaultInterpolation', $translateDefaultInterpolation);
-angular.module('pascalprecht.translate')
+ function $translateDefaultInterpolation($interpolate, $translateSanitization) {
-/**
- * @ngdoc object
- * @name pascalprecht.translate.$translationCache
- * @requires $cacheFactory
- *
- * @description
- * The first time a translation table is used, it is loaded in the translation cache for quick retrieval. You
- * can load translation tables directly into the cache by consuming the
- * `$translationCache` service directly.
- *
- * @return {object} $cacheFactory object.
- */
- .factory('$translationCache', $translationCache);
+ 'use strict';
-function $translationCache($cacheFactory) {
+ var $translateInterpolator = {},
+ $locale,
+ $identifier = 'default';
- 'use strict';
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateDefaultInterpolation#setLocale
+ * @methodOf pascalprecht.translate.$translateDefaultInterpolation
+ *
+ * @description
+ * Sets current locale (this is currently not use in this interpolation).
+ *
+ * @param {string} locale Language key or locale.
+ */
+ $translateInterpolator.setLocale = function (locale) {
+ $locale = locale;
+ };
- return $cacheFactory('translations');
-}
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateDefaultInterpolation#getInterpolationIdentifier
+ * @methodOf pascalprecht.translate.$translateDefaultInterpolation
+ *
+ * @description
+ * Returns an identifier for this interpolation service.
+ *
+ * @returns {string} $identifier
+ */
+ $translateInterpolator.getInterpolationIdentifier = function () {
+ return $identifier;
+ };
-$translationCache.displayName = '$translationCache';
-return 'pascalprecht.translate';
+ /**
+ * @deprecated will be removed in 3.0
+ * @see {@link pascalprecht.translate.$translateSanitization}
+ */
+ $translateInterpolator.useSanitizeValueStrategy = function (value) {
+ $translateSanitization.useStrategy(value);
+ return this;
+ };
-}));
-
-},{}],112:[function(require,module,exports){
-/**
- * @license AngularJS v1.6.4
- * (c) 2010-2017 Google, Inc. http://angularjs.org
- * License: MIT
- */
-(function(window) {'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
- */
+ /**
+ * @ngdoc function
+ * @name pascalprecht.translate.$translateDefaultInterpolation#interpolate
+ * @methodOf pascalprecht.translate.$translateDefaultInterpolation
+ *
+ * @description
+ * Interpolates given value agains given interpolate params using angulars
+ * `$interpolate` service.
+ *
+ * Since AngularJS 1.5, `value` must not be a string but can be anything input.
+ *
+ * @param {string} value translation
+ * @param {object} interpolationParams interpolation params
+ * @param {string} context current context (filter, directive, service)
+ * @param {string} sanitizeStrategy sanitize strategy
+ * @param {string} translationId current translationId
+ *
+ * @returns {string} interpolated string
+ */
+ $translateInterpolator.interpolate = function (value, interpolationParams, context, sanitizeStrategy, translationId) {
+ // jshint ignore:line
+ interpolationParams = interpolationParams || {};
+ interpolationParams = $translateSanitization.sanitize(interpolationParams, 'params', sanitizeStrategy, context);
+
+ var interpolatedText;
+ if (angular.isNumber(value)) {
+ // numbers are safe
+ interpolatedText = '' + value;
+ } else if (angular.isString(value)) {
+ // strings must be interpolated (that's the job here)
+ interpolatedText = $interpolate(value)(interpolationParams);
+ interpolatedText = $translateSanitization.sanitize(interpolatedText, 'text', sanitizeStrategy, context);
+ } else {
+ // neither a number or a string, cant interpolate => empty string
+ interpolatedText = '';
+ }
-function minErr(module, ErrorConstructor) {
- ErrorConstructor = ErrorConstructor || Error;
- return function() {
- var code = arguments[0],
- template = arguments[1],
- message = '[' + (module ? module + ':' : '') + code + '] ',
- templateArgs = sliceArgs(arguments, 2).map(function(arg) {
- return toDebugString(arg, minErrConfig.objectMaxDepth);
- }),
- paramPrefix, i;
+ return interpolatedText;
+ };
- message += template.replace(/\{\d+\}/g, function(match) {
- var index = +match.slice(1, -1);
+ return $translateInterpolator;
+ }
- if (index < templateArgs.length) {
- return templateArgs[index];
- }
+ $translateDefaultInterpolation.displayName = '$translateDefaultInterpolation';
- return match;
- });
+ angular.module('pascalprecht.translate').constant('$STORAGE_KEY', 'NG_TRANSLATE_LANG_KEY');
- message += '\nhttp://errors.angularjs.org/1.6.4/' +
- (module ? module + '/' : '') + code;
+ angular.module('pascalprecht.translate')
+ /**
+ * @ngdoc directive
+ * @name pascalprecht.translate.directive:translate
+ * @requires $interpolate,
+ * @requires $compile,
+ * @requires $parse,
+ * @requires $rootScope
+ * @restrict AE
+ *
+ * @description
+ * Translates given translation id either through attribute or DOM content.
+ * Internally it uses $translate service to translate the translation id. It possible to
+ * pass an optional `translate-values` object literal as string into translation id.
+ *
+ * @param {string=} translate Translation id which could be either string or interpolated string.
+ * @param {string=} translate-values Values to pass into translation id. Can be passed as object literal string or interpolated object.
+ * @param {string=} translate-attr-ATTR translate Translation id and put it into ATTR attribute.
+ * @param {string=} translate-default will be used unless translation was successful
+ * @param {boolean=} translate-compile (default true if present) defines locally activation of {@link pascalprecht.translate.$translateProvider#methods_usePostCompiling}
+ * @param {boolean=} translate-keep-content (default true if present) defines that in case a KEY could not be translated, that the existing content is left in the innerHTML}
+ *
+ * @example
+
+
+
+
+
+
TRANSLATION_ID
+
+
+
{{translationId}}
+
+
WITH_VALUES
+
+
WITH_VALUES
+
+
+
+
TRANSLATION_ID
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toBe('Hello there!');
+
+ element = $compile('{{translationId}}
')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toBe('Hello there!');
+
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect(element.attr('title')).toBe('Hello there!');
+
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect(element.text()).toBe('The interpolation key is camel cased: Hello');
+ });
+ });
+
+
+ */
+ .directive('translate', translateDirective);
+ function translateDirective($translate, $interpolate, $compile, $parse, $rootScope) {
- for (i = 0, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
- message += paramPrefix + 'p' + i + '=' + encodeURIComponent(templateArgs[i]);
- }
+ 'use strict';
- return new ErrorConstructor(message);
- };
-}
+ /**
+ * @name trim
+ * @private
+ *
+ * @description
+ * trim polyfill
+ *
+ * @returns {string} The string stripped of whitespace from both ends
+ */
-/* We need to tell ESLint what variables are being exported */
-/* exported
- angular,
- msie,
- jqLite,
- jQuery,
- slice,
- splice,
- push,
- toString,
- minErrConfig,
- errorHandlingConfig,
- isValidObjectMaxDepth,
- ngMinErr,
- angularModule,
- uid,
- REGEX_STRING_REGEXP,
- VALIDITY_STATE_PROPERTY,
-
- lowercase,
- uppercase,
- manualLowercase,
- manualUppercase,
- nodeName_,
- isArrayLike,
- forEach,
- forEachSorted,
- reverseParams,
- nextUid,
- setHashKey,
- extend,
- toInt,
- inherit,
- merge,
- noop,
- identity,
- valueFn,
- isUndefined,
- isDefined,
- isObject,
- isBlankObject,
- isString,
- isNumber,
- isNumberNaN,
- isDate,
- isArray,
- isFunction,
- isRegExp,
- isWindow,
- isScope,
- isFile,
- isFormData,
- isBlob,
- isBoolean,
- isPromiseLike,
- trim,
- escapeForRegexp,
- isElement,
- makeMap,
- includes,
- arrayRemove,
- copy,
- simpleCompare,
- equals,
- csp,
- jq,
- concat,
- sliceArgs,
- bind,
- toJsonReplacer,
- toJson,
- fromJson,
- convertTimezoneToLocal,
- timezoneToOffset,
- startingTag,
- tryDecodeURIComponent,
- parseKeyValue,
- toKeyValue,
- encodeUriSegment,
- encodeUriQuery,
- angularInit,
- bootstrap,
- getTestability,
- snake_case,
- bindJQuery,
- assertArg,
- assertArgFn,
- assertNotHasOwnProperty,
- getter,
- getBlockNodes,
- hasOwnProperty,
- createMap,
- stringify,
-
- NODE_TYPE_ELEMENT,
- NODE_TYPE_ATTRIBUTE,
- NODE_TYPE_TEXT,
- NODE_TYPE_COMMENT,
- NODE_TYPE_DOCUMENT,
- NODE_TYPE_DOCUMENT_FRAGMENT
-*/
+ var trim = function trim() {
+ return this.toString().replace(/^\s+|\s+$/g, '');
+ };
-////////////////////////////////////
+ return {
+ restrict: 'AE',
+ scope: true,
+ priority: $translate.directivePriority(),
+ compile: function compile(tElement, tAttr) {
-/**
- * @ngdoc module
- * @name ng
- * @module ng
- * @installation
- * @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.
- *
- *
- */
+ var translateValuesExist = tAttr.translateValues ? tAttr.translateValues : undefined;
-var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
+ var translateInterpolation = tAttr.translateInterpolation ? tAttr.translateInterpolation : undefined;
-// 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';
+ var translateValueExist = tElement[0].outerHTML.match(/translate-value-+/i);
+ var interpolateRegExp = '^(.*)(' + $interpolate.startSymbol() + '.*' + $interpolate.endSymbol() + ')(.*)',
+ watcherRegExp = '^(.*)' + $interpolate.startSymbol() + '(.*)' + $interpolate.endSymbol() + '(.*)';
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+ return function linkFn(scope, iElement, iAttr) {
-var minErrConfig = {
- objectMaxDepth: 5
-};
+ scope.interpolateParams = {};
+ scope.preText = '';
+ scope.postText = '';
+ scope.translateNamespace = getTranslateNamespace(scope);
+ var translationIds = {};
- /**
- * @ngdoc function
- * @name angular.errorHandlingConfig
- * @module ng
- * @kind function
- *
- * @description
- * Configure several aspects of error handling in AngularJS if used as a setter or return the
- * current configuration if used as a getter. The following options are supported:
- *
- * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
- *
- * Omitted or undefined options will leave the corresponding configuration values unchanged.
- *
- * @param {Object=} config - The configuration object. May only contain the options that need to be
- * updated. Supported keys:
- *
- * * `objectMaxDepth` **{Number}** - The max depth for stringifying objects. Setting to a
- * non-positive or non-numeric value, removes the max depth limit.
- * Default: 5
- */
-function errorHandlingConfig(config) {
- if (isObject(config)) {
- if (isDefined(config.objectMaxDepth)) {
- minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth) ? config.objectMaxDepth : NaN;
- }
- } else {
- return minErrConfig;
- }
-}
+ var initInterpolationParams = function initInterpolationParams(interpolateParams, iAttr, tAttr) {
+ // initial setup
+ if (iAttr.translateValues) {
+ angular.extend(interpolateParams, $parse(iAttr.translateValues)(scope.$parent));
+ }
+ // initially fetch all attributes if existing and fill the params
+ if (translateValueExist) {
+ for (var attr in tAttr) {
+ if (Object.prototype.hasOwnProperty.call(iAttr, attr) && attr.substr(0, 14) === 'translateValue' && attr !== 'translateValues') {
+ var attributeName = angular.lowercase(attr.substr(14, 1)) + attr.substr(15);
+ interpolateParams[attributeName] = tAttr[attr];
+ }
+ }
+ }
+ };
-/**
- * @private
- * @param {Number} maxDepth
- * @return {boolean}
- */
-function isValidObjectMaxDepth(maxDepth) {
- return isNumber(maxDepth) && maxDepth > 0;
-}
+ // Ensures any change of the attribute "translate" containing the id will
+ // be re-stored to the scope's "translationId".
+ // If the attribute has no content, the element's text value (white spaces trimmed off) will be used.
+ var observeElementTranslation = function observeElementTranslation(translationId) {
-/**
- * @ngdoc function
- * @name angular.lowercase
- * @module ng
- * @kind function
- *
- * @deprecated
- * sinceVersion="1.5.0"
- * removeVersion="1.7.0"
- * Use [String.prototype.toLowerCase](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) instead.
- *
- * @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;};
+ // Remove any old watcher
+ if (angular.isFunction(observeElementTranslation._unwatchOld)) {
+ observeElementTranslation._unwatchOld();
+ observeElementTranslation._unwatchOld = undefined;
+ }
-/**
- * @ngdoc function
- * @name angular.uppercase
- * @module ng
- * @kind function
- *
- * @deprecated
- * sinceVersion="1.5.0"
- * removeVersion="1.7.0"
- * Use [String.prototype.toUpperCase](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) instead.
- *
- * @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;};
+ if (angular.equals(translationId, '') || !angular.isDefined(translationId)) {
+ var iElementText = trim.apply(iElement.text());
+
+ // Resolve translation id by inner html if required
+ var interpolateMatches = iElementText.match(interpolateRegExp);
+ // Interpolate translation id if required
+ if (angular.isArray(interpolateMatches)) {
+ scope.preText = interpolateMatches[1];
+ scope.postText = interpolateMatches[3];
+ translationIds.translate = $interpolate(interpolateMatches[2])(scope.$parent);
+ var watcherMatches = iElementText.match(watcherRegExp);
+ if (angular.isArray(watcherMatches) && watcherMatches[2] && watcherMatches[2].length) {
+ observeElementTranslation._unwatchOld = scope.$watch(watcherMatches[2], function (newValue) {
+ translationIds.translate = newValue;
+ updateTranslations();
+ });
+ }
+ } else {
+ // do not assigne the translation id if it is empty.
+ translationIds.translate = !iElementText ? undefined : iElementText;
+ }
+ } else {
+ translationIds.translate = translationId;
+ }
+ updateTranslations();
+ };
+ var observeAttributeTranslation = function observeAttributeTranslation(translateAttr) {
+ iAttr.$observe(translateAttr, function (translationId) {
+ translationIds[translateAttr] = translationId;
+ updateTranslations();
+ });
+ };
-var manualLowercase = function(s) {
- /* eslint-disable no-bitwise */
- return isString(s)
- ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);})
- : s;
- /* eslint-enable */
-};
-var manualUppercase = function(s) {
- /* eslint-disable no-bitwise */
- return isString(s)
- ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
- : s;
- /* eslint-enable */
-};
+ // initial setup with values
+ initInterpolationParams(scope.interpolateParams, iAttr, tAttr);
+ var firstAttributeChangedEvent = true;
+ iAttr.$observe('translate', function (translationId) {
+ if (typeof translationId === 'undefined') {
+ // case of element "
xyz"
+ observeElementTranslation('');
+ } else {
+ // case of regular attribute
+ if (translationId !== '' || !firstAttributeChangedEvent) {
+ translationIds.translate = translationId;
+ updateTranslations();
+ }
+ }
+ firstAttributeChangedEvent = false;
+ });
-// 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. See https://github.com/angular/angular.js/issues/11387
-if ('i' !== 'I'.toLowerCase()) {
- lowercase = manualLowercase;
- uppercase = manualUppercase;
-}
+ for (var translateAttr in iAttr) {
+ if (iAttr.hasOwnProperty(translateAttr) && translateAttr.substr(0, 13) === 'translateAttr' && translateAttr.length > 13) {
+ observeAttributeTranslation(translateAttr);
+ }
+ }
+ iAttr.$observe('translateDefault', function (value) {
+ scope.defaultText = value;
+ updateTranslations();
+ });
-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'),
+ if (translateValuesExist) {
+ iAttr.$observe('translateValues', function (interpolateParams) {
+ if (interpolateParams) {
+ scope.$parent.$watch(function () {
+ angular.extend(scope.interpolateParams, $parse(interpolateParams)(scope.$parent));
+ });
+ }
+ });
+ }
- /** @name angular */
- angular = window.angular || (window.angular = {}),
- angularModule,
- uid = 0;
+ if (translateValueExist) {
+ var observeValueAttribute = function observeValueAttribute(attrName) {
+ iAttr.$observe(attrName, function (value) {
+ var attributeName = angular.lowercase(attrName.substr(14, 1)) + attrName.substr(15);
+ scope.interpolateParams[attributeName] = value;
+ });
+ };
+ for (var attr in iAttr) {
+ if (Object.prototype.hasOwnProperty.call(iAttr, attr) && attr.substr(0, 14) === 'translateValue' && attr !== 'translateValues') {
+ observeValueAttribute(attr);
+ }
+ }
+ }
-// Support: IE 9-11 only
-/**
- * documentMode is an IE-only property
- * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
- */
-msie = window.document.documentMode;
+ // Master update function
+ var updateTranslations = function updateTranslations() {
+ for (var key in translationIds) {
+ if (translationIds.hasOwnProperty(key) && translationIds[key] !== undefined) {
+ updateTranslation(key, translationIds[key], scope, scope.interpolateParams, scope.defaultText, scope.translateNamespace);
+ }
+ }
+ };
+ // Put translation processing function outside loop
+ var updateTranslation = function updateTranslation(translateAttr, translationId, scope, interpolateParams, defaultTranslationText, translateNamespace) {
+ if (translationId) {
+ // if translation id starts with '.' and translateNamespace given, prepend namespace
+ if (translateNamespace && translationId.charAt(0) === '.') {
+ translationId = translateNamespace + translationId;
+ }
-/**
- * @private
- * @param {*} obj
- * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
- * String ...)
- */
-function isArrayLike(obj) {
+ $translate(translationId, interpolateParams, translateInterpolation, defaultTranslationText, scope.translateLanguage).then(function (translation) {
+ applyTranslation(translation, scope, true, translateAttr);
+ }, function (translationId) {
+ applyTranslation(translationId, scope, false, translateAttr);
+ });
+ } else {
+ // as an empty string cannot be translated, we can solve this using successful=false
+ applyTranslation(translationId, scope, false, translateAttr);
+ }
+ };
- // `null`, `undefined` and `window` are not array-like
- if (obj == null || isWindow(obj)) return false;
+ var applyTranslation = function applyTranslation(value, scope, successful, translateAttr) {
+ if (!successful) {
+ if (typeof scope.defaultText !== 'undefined') {
+ value = scope.defaultText;
+ }
+ }
+ if (translateAttr === 'translate') {
+ // default translate into innerHTML
+ if (successful || !successful && !$translate.isKeepContent() && typeof iAttr.translateKeepContent === 'undefined') {
+ iElement.empty().append(scope.preText + value + scope.postText);
+ }
+ var globallyEnabled = $translate.isPostCompilingEnabled();
+ var locallyDefined = typeof tAttr.translateCompile !== 'undefined';
+ var locallyEnabled = locallyDefined && tAttr.translateCompile !== 'false';
+ if (globallyEnabled && !locallyDefined || locallyEnabled) {
+ $compile(iElement.contents())(scope);
+ }
+ } else {
+ // translate attribute
+ var attributeName = iAttr.$attr[translateAttr];
+ if (attributeName.substr(0, 5) === 'data-') {
+ // ensure html5 data prefix is stripped
+ attributeName = attributeName.substr(5);
+ }
+ attributeName = attributeName.substr(15);
+ iElement.attr(attributeName, value);
+ }
+ };
- // arrays, strings and jQuery/jqLite objects are array like
- // * jqLite is either the jQuery or jqLite constructor function
- // * we have to check the existence of jqLite first as this method is called
- // via the forEach method when constructing the jqLite object in the first place
- if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
+ if (translateValuesExist || translateValueExist || iAttr.translateDefault) {
+ scope.$watch('interpolateParams', updateTranslations, true);
+ }
- // 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;
+ // Replaced watcher on translateLanguage with event listener
+ scope.$on('translateLanguageChanged', updateTranslations);
- // NodeList objects (with `item` method) and
- // other objects with suitable length characteristics are array-like
- return isNumber(length) &&
- (length >= 0 && ((length - 1) in obj || obj instanceof Array) || typeof obj.item === 'function');
+ // Ensures the text will be refreshed after the current language was changed
+ // w/ $translate.use(...)
+ var unbind = $rootScope.$on('$translateChangeSuccess', updateTranslations);
-}
+ // ensure translation will be looked up at least one
+ if (iElement.text().length) {
+ if (iAttr.translate) {
+ observeElementTranslation(iAttr.translate);
+ } else {
+ observeElementTranslation('');
+ }
+ } else if (iAttr.translate) {
+ // ensure attribute will be not skipped
+ observeElementTranslation(iAttr.translate);
+ }
+ updateTranslations();
+ scope.$on('$destroy', unbind);
+ };
+ }
+ };
+ }
-/**
- * @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`.
- */
+ /**
+ * Returns the scope's namespace.
+ * @private
+ * @param scope
+ * @returns {string}
+ */
+ function getTranslateNamespace(scope) {
+ 'use strict';
-function forEach(obj, iterator, context) {
- var key, length;
- if (obj) {
- if (isFunction(obj)) {
- for (key in obj) {
- if (key !== 'prototype' && key !== 'length' && key !== 'name' && 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);
- }
- }
+ if (scope.translateNamespace) {
+ return scope.translateNamespace;
+ }
+ if (scope.$parent) {
+ return getTranslateNamespace(scope.$parent);
}
}
- 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;
-}
+ translateDirective.displayName = 'translateDirective';
+ angular.module('pascalprecht.translate')
+ /**
+ * @ngdoc directive
+ * @name pascalprecht.translate.directive:translate-attr
+ * @restrict A
+ *
+ * @description
+ * Translates attributes like translate-attr-ATTR, but with an object like ng-class.
+ * Internally it uses `translate` service to translate translation id. It possible to
+ * pass an optional `translate-values` object literal as string into translation id.
+ *
+ * @param {string=} translate-attr Object literal mapping attributes to translation ids.
+ * @param {string=} translate-values Values to pass into the translation ids. Can be passed as object literal string.
+ *
+ * @example
+
+
+
+
+
+
+
+
+
+ angular.module('ngView', ['pascalprecht.translate'])
+
+ .config(function ($translateProvider) {
+
+ $translateProvider.translations('en',{
+ 'TRANSLATION_ID': 'Hello there!',
+ 'WITH_VALUES': 'The following value is dynamic: {{value}}',
+ }).preferredLanguage('en');
+
+ });
+
+ angular.module('ngView').controller('TranslateCtrl', function ($scope) {
+ $scope.translationId = 'TRANSLATION_ID';
+
+ $scope.values = {
+ value: 78
+ };
+ });
+
+
+ it('should translate', function () {
+ inject(function ($rootScope, $compile) {
+ $rootScope.translationId = 'TRANSLATION_ID';
+
+ element = $compile('')($rootScope);
+ $rootScope.$digest();
+ expect(element.attr('placeholder)).toBe('Hello there!');
+ expect(element.attr('title)).toBe('The following value is dynamic: 5');
+ });
+ });
+
+
+ */
+ .directive('translateAttr', translateAttrDirective);
+ function translateAttrDirective($translate, $rootScope) {
-/**
- * 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);};
-}
+ 'use strict';
-/**
- * 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;
-}
+ return {
+ restrict: 'A',
+ priority: $translate.directivePriority(),
+ link: function linkFn(scope, element, attr) {
+ var translateAttr,
+ translateValues,
+ previousAttributes = {};
-/**
- * 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;
- }
-}
+ // Main update translations function
+ var updateTranslations = function updateTranslations() {
+ angular.forEach(translateAttr, function (translationId, attributeName) {
+ if (!translationId) {
+ return;
+ }
+ previousAttributes[attributeName] = true;
+ // if translation id starts with '.' and translateNamespace given, prepend namespace
+ if (scope.translateNamespace && translationId.charAt(0) === '.') {
+ translationId = scope.translateNamespace + translationId;
+ }
+ $translate(translationId, translateValues, attr.translateInterpolation, undefined, scope.translateLanguage).then(function (translation) {
+ element.attr(attributeName, translation);
+ }, function (translationId) {
+ element.attr(attributeName, translationId);
+ });
+ });
-function baseExtend(dst, objs, deep) {
- var h = dst.$$hashKey;
+ // Removing unused attributes that were previously used
+ angular.forEach(previousAttributes, function (flag, attributeName) {
+ if (!translateAttr[attributeName]) {
+ element.removeAttr(attributeName);
+ delete previousAttributes[attributeName];
+ }
+ });
+ };
- 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];
+ // Watch for attribute changes
+ watchAttribute(scope, attr.translateAttr, function (newValue) {
+ translateAttr = newValue;
+ }, updateTranslations);
+ // Watch for value changes
+ watchAttribute(scope, attr.translateValues, function (newValue) {
+ translateValues = newValue;
+ }, updateTranslations);
- if (deep && isObject(src)) {
- if (isDate(src)) {
- dst[key] = new Date(src.valueOf());
- } else if (isRegExp(src)) {
- dst[key] = new RegExp(src);
- } else if (src.nodeName) {
- dst[key] = src.cloneNode(true);
- } else if (isElement(src)) {
- dst[key] = src.clone();
- } else {
- if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
- baseExtend(dst[key], [src], true);
+ if (attr.translateValues) {
+ scope.$watch(attr.translateValues, updateTranslations, true);
}
- } else {
- dst[key] = src;
+
+ // Replaced watcher on translateLanguage with event listener
+ scope.$on('translateLanguageChanged', updateTranslations);
+
+ // Ensures the text will be refreshed after the current language was changed
+ // w/ $translate.use(...)
+ var unbind = $rootScope.$on('$translateChangeSuccess', updateTranslations);
+
+ updateTranslations();
+ scope.$on('$destroy', unbind);
}
+ };
+ }
+
+ function watchAttribute(scope, attribute, valueCallback, changeCallback) {
+ 'use strict';
+
+ if (!attribute) {
+ return;
+ }
+ if (attribute.substr(0, 2) === '::') {
+ attribute = attribute.substr(2);
+ } else {
+ scope.$watch(attribute, function (newValue) {
+ valueCallback(newValue);
+ changeCallback();
+ }, true);
}
+ valueCallback(scope.$eval(attribute));
}
- setHashKey(dst, h);
- return dst;
-}
+ translateAttrDirective.displayName = 'translateAttrDirective';
-/**
- * @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);
-}
+ angular.module('pascalprecht.translate')
+ /**
+ * @ngdoc directive
+ * @name pascalprecht.translate.directive:translateCloak
+ * @requires $translate
+ * @restrict A
+ *
+ * $description
+ * Adds a `translate-cloak` class name to the given element where this directive
+ * is applied initially and removes it, once a loader has finished loading.
+ *
+ * This directive can be used to prevent initial flickering when loading translation
+ * data asynchronously.
+ *
+ * The class name is defined in
+ * {@link pascalprecht.translate.$translateProvider#cloakClassName $translate.cloakClassName()}.
+ *
+ * @param {string=} translate-cloak If a translationId is provided, it will be used for showing
+ * or hiding the cloak. Basically it relies on the translation
+ * resolve.
+ */
+ .directive('translateCloak', translateCloakDirective);
+ function translateCloakDirective($translate, $rootScope) {
-/**
-* @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);
-}
+ 'use strict';
+ return {
+ compile: function compile(tElement) {
+ var applyCloak = function applyCloak(element) {
+ element.addClass($translate.cloakClassName());
+ },
+ removeCloak = function removeCloak(element) {
+ element.removeClass($translate.cloakClassName());
+ };
+ applyCloak(tElement);
+
+ return function linkFn(scope, iElement, iAttr) {
+ //Create bound functions that incorporate the active DOM element.
+ var iRemoveCloak = removeCloak.bind(this, iElement),
+ iApplyCloak = applyCloak.bind(this, iElement);
+ if (iAttr.translateCloak && iAttr.translateCloak.length) {
+ // Register a watcher for the defined translation allowing a fine tuned cloak
+ iAttr.$observe('translateCloak', function (translationId) {
+ $translate(translationId).then(iRemoveCloak, iApplyCloak);
+ });
+ $rootScope.$on('$translateChangeSuccess', function () {
+ $translate(iAttr.translateCloak).then(iRemoveCloak, iApplyCloak);
+ });
+ } else {
+ $translate.onReady(iRemoveCloak);
+ }
+ };
+ }
+ };
+ }
+ translateCloakDirective.displayName = 'translateCloakDirective';
-function toInt(str) {
- return parseInt(str, 10);
-}
+ angular.module('pascalprecht.translate')
+ /**
+ * @ngdoc directive
+ * @name pascalprecht.translate.directive:translateNamespace
+ * @restrict A
+ *
+ * @description
+ * Translates given translation id either through attribute or DOM content.
+ * Internally it uses `translate` filter to translate translation id. It possible to
+ * pass an optional `translate-values` object literal as string into translation id.
+ *
+ * @param {string=} translate namespace name which could be either string or interpolated string.
+ *
+ * @example
+
+
+
+
+
+
.HEADERS.TITLE
+ .HEADERS.WELCOME
+
+
+
+
.TITLE
+ .WELCOME
+
+
+
+ */
+ .directive('translateNamespace', translateNamespaceDirective);
-var isNumberNaN = Number.isNaN || function isNumberNaN(num) {
- // eslint-disable-next-line no-self-compare
- return num !== num;
-};
+ function translateNamespaceDirective() {
+ 'use strict';
-function inherit(parent, extra) {
- return extend(Object.create(parent), extra);
-}
+ return {
+ restrict: 'A',
+ scope: true,
+ compile: function compile() {
+ return {
+ pre: function pre(scope, iElement, iAttrs) {
+ scope.translateNamespace = getTranslateNamespace(scope);
-/**
- * @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 = [];
+ if (scope.translateNamespace && iAttrs.translateNamespace.charAt(0) === '.') {
+ scope.translateNamespace += iAttrs.translateNamespace;
+ } else {
+ scope.translateNamespace = iAttrs.translateNamespace;
+ }
+ }
+ };
+ }
+ };
+ }
+ /**
+ * Returns the scope's namespace.
+ * @private
+ * @param scope
+ * @returns {string}
+ */
+ function getTranslateNamespace(scope) {
+ 'use strict';
-/**
- * @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);
- };
+ if (scope.translateNamespace) {
+ return scope.translateNamespace;
+ }
+ if (scope.$parent) {
+ return getTranslateNamespace(scope.$parent);
+ }
+ }
- // E.g.
- function getResult(fn, input) {
- return (fn || angular.identity)(input);
- };
+ translateNamespaceDirective.displayName = 'translateNamespaceDirective';
- getResult(function(n) { return n * 2; }, 21); // returns 42
- getResult(null, 21); // returns 21
- getResult(undefined, 21); // returns 21
- ```
- *
- * @param {*} value to be returned.
- * @returns {*} the value passed in.
- */
-function identity($) {return $;}
-identity.$inject = [];
+ angular.module('pascalprecht.translate')
+ /**
+ * @ngdoc directive
+ * @name pascalprecht.translate.directive:translateLanguage
+ * @restrict A
+ *
+ * @description
+ * Forces the language to the directives in the underlying scope.
+ *
+ * @param {string=} translate language that will be negotiated.
+ *
+ * @example
+
+
+
+
+
+
HELLO
+
+
+
+
HELLO
+
+
+
+ */
+ .directive('translateLanguage', translateLanguageDirective);
+ function translateLanguageDirective() {
-function valueFn(value) {return function valueRef() {return value;};}
+ 'use strict';
-function hasCustomToString(obj) {
- return isFunction(obj.toString) && obj.toString !== toString;
-}
+ return {
+ restrict: 'A',
+ scope: true,
+ compile: function compile() {
+ return function linkFn(scope, iElement, iAttrs) {
+ iAttrs.$observe('translateLanguage', function (newTranslateLanguage) {
+ scope.translateLanguage = newTranslateLanguage;
+ });
-/**
- * @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';}
+ scope.$watch('translateLanguage', function () {
+ scope.$broadcast('translateLanguageChanged');
+ });
+ };
+ }
+ };
+ }
+ translateLanguageDirective.displayName = 'translateLanguageDirective';
-/**
- * @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';}
+ angular.module('pascalprecht.translate')
+ /**
+ * @ngdoc filter
+ * @name pascalprecht.translate.filter:translate
+ * @requires $parse
+ * @requires pascalprecht.translate.$translate
+ * @function
+ *
+ * @description
+ * Uses `$translate` service to translate contents. Accepts interpolate parameters
+ * to pass dynamized values though translation.
+ *
+ * @param {string} translationId A translation id to be translated.
+ * @param {*=} interpolateParams Optional object literal (as hash or string) to pass values into translation.
+ *
+ * @returns {string} Translated text.
+ *
+ * @example
+
+
+
+
+
{{ 'TRANSLATION_ID' | translate }}
+
{{ translationId | translate }}
+
{{ 'WITH_VALUES' | translate:'{value: 5}' }}
+
{{ 'WITH_VALUES' | translate:values }}
+
+
+ */
+ .filter('translate', translateFilterFactory);
+ function translateFilterFactory($parse, $translate) {
-/**
- * @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';
-}
+ 'use strict';
+ var translateFilter = function translateFilter(translationId, interpolateParams, interpolation, forceLanguage) {
+ if (!angular.isObject(interpolateParams)) {
+ var ctx = this || {
+ '__SCOPE_IS_NOT_AVAILABLE': 'More info at https://github.com/angular/angular.js/commit/8863b9d04c722b278fa93c5d66ad1e578ad6eb1f'
+ };
+ interpolateParams = $parse(interpolateParams)(ctx);
+ }
-/**
- * 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);
-}
+ return $translate.instant(translationId, interpolateParams, interpolation, forceLanguage);
+ };
+ if ($translate.statefulFilter()) {
+ translateFilter.$stateful = true;
+ }
-/**
- * @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';}
+ return translateFilter;
+ }
+ translateFilterFactory.displayName = 'translateFilterFactory';
-/**
- * @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';}
+ angular.module('pascalprecht.translate')
+
+ /**
+ * @ngdoc object
+ * @name pascalprecht.translate.$translationCache
+ * @requires $cacheFactory
+ *
+ * @description
+ * The first time a translation table is used, it is loaded in the translation cache for quick retrieval. You
+ * can load translation tables directly into the cache by consuming the
+ * `$translationCache` service directly.
+ *
+ * @return {object} $cacheFactory object.
+ */
+ .factory('$translationCache', $translationCache);
+ function $translationCache($cacheFactory) {
-/**
- * @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]';
-}
+ 'use strict';
+ return $cacheFactory('translations');
+ }
-/**
- * @ngdoc function
- * @name angular.isArray
- * @module ng
- * @kind function
- *
- * @description
- * Determines if a reference is an `Array`. Alias of Array.isArray.
- *
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is an `Array`.
- */
-var isArray = Array.isArray;
+ $translationCache.displayName = '$translationCache';
+ return 'pascalprecht.translate';
+});
-/**
- * @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';}
+},{}],112:[function(require,module,exports){
+'use strict';
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
/**
- * Determines if a value is a regular expression object.
- *
- * @private
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is a `RegExp`.
+ * @license AngularJS v1.6.4
+ * (c) 2010-2017 Google, Inc. http://angularjs.org
+ * License: MIT
*/
-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 (window) {
+ '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 isScope(obj) {
- return obj && obj.$evalAsync && obj.$watch;
-}
+ function minErr(module, ErrorConstructor) {
+ ErrorConstructor = ErrorConstructor || Error;
+ return function () {
+ var code = arguments[0],
+ template = arguments[1],
+ message = '[' + (module ? module + ':' : '') + code + '] ',
+ templateArgs = sliceArgs(arguments, 2).map(function (arg) {
+ return toDebugString(arg, minErrConfig.objectMaxDepth);
+ }),
+ paramPrefix,
+ i;
+ message += template.replace(/\{\d+\}/g, function (match) {
+ var index = +match.slice(1, -1);
-function isFile(obj) {
- return toString.call(obj) === '[object File]';
-}
+ if (index < templateArgs.length) {
+ return templateArgs[index];
+ }
+ return match;
+ });
-function isFormData(obj) {
- return toString.call(obj) === '[object FormData]';
-}
+ message += '\nhttp://errors.angularjs.org/1.6.4/' + (module ? module + '/' : '') + code;
+ for (i = 0, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
+ message += paramPrefix + 'p' + i + '=' + encodeURIComponent(templateArgs[i]);
+ }
-function isBlob(obj) {
- return toString.call(obj) === '[object Blob]';
-}
+ return new ErrorConstructor(message);
+ };
+ }
+ /* We need to tell ESLint what variables are being exported */
+ /* exported
+ angular,
+ msie,
+ jqLite,
+ jQuery,
+ slice,
+ splice,
+ push,
+ toString,
+ minErrConfig,
+ errorHandlingConfig,
+ isValidObjectMaxDepth,
+ ngMinErr,
+ angularModule,
+ uid,
+ REGEX_STRING_REGEXP,
+ VALIDITY_STATE_PROPERTY,
+
+ lowercase,
+ uppercase,
+ manualLowercase,
+ manualUppercase,
+ nodeName_,
+ isArrayLike,
+ forEach,
+ forEachSorted,
+ reverseParams,
+ nextUid,
+ setHashKey,
+ extend,
+ toInt,
+ inherit,
+ merge,
+ noop,
+ identity,
+ valueFn,
+ isUndefined,
+ isDefined,
+ isObject,
+ isBlankObject,
+ isString,
+ isNumber,
+ isNumberNaN,
+ isDate,
+ isArray,
+ isFunction,
+ isRegExp,
+ isWindow,
+ isScope,
+ isFile,
+ isFormData,
+ isBlob,
+ isBoolean,
+ isPromiseLike,
+ trim,
+ escapeForRegexp,
+ isElement,
+ makeMap,
+ includes,
+ arrayRemove,
+ copy,
+ simpleCompare,
+ equals,
+ csp,
+ jq,
+ concat,
+ sliceArgs,
+ bind,
+ toJsonReplacer,
+ toJson,
+ fromJson,
+ convertTimezoneToLocal,
+ timezoneToOffset,
+ startingTag,
+ tryDecodeURIComponent,
+ parseKeyValue,
+ toKeyValue,
+ encodeUriSegment,
+ encodeUriQuery,
+ angularInit,
+ bootstrap,
+ getTestability,
+ snake_case,
+ bindJQuery,
+ assertArg,
+ assertArgFn,
+ assertNotHasOwnProperty,
+ getter,
+ getBlockNodes,
+ hasOwnProperty,
+ createMap,
+ stringify,
+
+ NODE_TYPE_ELEMENT,
+ NODE_TYPE_ATTRIBUTE,
+ NODE_TYPE_TEXT,
+ NODE_TYPE_COMMENT,
+ NODE_TYPE_DOCUMENT,
+ NODE_TYPE_DOCUMENT_FRAGMENT
+ */
-function isBoolean(value) {
- return typeof value === 'boolean';
-}
+ ////////////////////////////////////
+ /**
+ * @ngdoc module
+ * @name ng
+ * @module ng
+ * @installation
+ * @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.
+ *
+ *
+ */
-function isPromiseLike(obj) {
- return obj && isFunction(obj.then);
-}
+ 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';
-var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array]$/;
-function isTypedArray(value) {
- return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
-}
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
-function isArrayBuffer(obj) {
- return toString.call(obj) === '[object ArrayBuffer]';
-}
+ var minErrConfig = {
+ objectMaxDepth: 5
+ };
+ /**
+ * @ngdoc function
+ * @name angular.errorHandlingConfig
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Configure several aspects of error handling in AngularJS if used as a setter or return the
+ * current configuration if used as a getter. The following options are supported:
+ *
+ * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
+ *
+ * Omitted or undefined options will leave the corresponding configuration values unchanged.
+ *
+ * @param {Object=} config - The configuration object. May only contain the options that need to be
+ * updated. Supported keys:
+ *
+ * * `objectMaxDepth` **{Number}** - The max depth for stringifying objects. Setting to a
+ * non-positive or non-numeric value, removes the max depth limit.
+ * Default: 5
+ */
+ function errorHandlingConfig(config) {
+ if (isObject(config)) {
+ if (isDefined(config.objectMaxDepth)) {
+ minErrConfig.objectMaxDepth = isValidObjectMaxDepth(config.objectMaxDepth) ? config.objectMaxDepth : NaN;
+ }
+ } else {
+ return minErrConfig;
+ }
+ }
-var trim = function(value) {
- return isString(value) ? value.trim() : value;
-};
+ /**
+ * @private
+ * @param {Number} maxDepth
+ * @return {boolean}
+ */
+ function isValidObjectMaxDepth(maxDepth) {
+ return isNumber(maxDepth) && maxDepth > 0;
+ }
-// 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(/([-()[\]{}+?*.$^|,:#= 0) {
- array.splice(index, 1);
- }
- return index;
-}
+ /** @name angular */
+ angular = window.angular || (window.angular = {}),
+ angularModule,
+ uid = 0;
-/**
- * @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.
- *
- *
- *
- * Only enumerable properties are taken into account. Non-enumerable properties (both on `source`
- * and on `destination`) will be ignored.
- *
- *
- * @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
-
-
-
-
-
form = {{user | json}}
-
master = {{master | json}}
-
- */
-function copy(source, destination, maxDepth) {
- var stackSource = [];
- var stackDest = [];
- maxDepth = isValidObjectMaxDepth(maxDepth) ? maxDepth : NaN;
+ // `null`, `undefined` and `window` are not array-like
+ if (obj == null || isWindow(obj)) return false;
- if (destination) {
- if (isTypedArray(destination) || isArrayBuffer(destination)) {
- throw ngMinErr('cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
- }
- if (source === destination) {
- throw ngMinErr('cpi', 'Can\'t copy! Source and destination are identical.');
- }
+ // arrays, strings and jQuery/jqLite objects are array like
+ // * jqLite is either the jQuery or jqLite constructor function
+ // * we have to check the existence of jqLite first as this method is called
+ // via the forEach method when constructing the jqLite object in the first place
+ if (isArray(obj) || isString(obj) || jqLite && obj instanceof jqLite) return true;
- // Empty the destination object
- if (isArray(destination)) {
- destination.length = 0;
- } else {
- forEach(destination, function(value, key) {
- if (key !== '$$hashKey') {
- delete destination[key];
- }
- });
- }
+ // 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;
- stackSource.push(source);
- stackDest.push(destination);
- return copyRecurse(source, destination, maxDepth);
+ // NodeList objects (with `item` method) and
+ // other objects with suitable length characteristics are array-like
+ return isNumber(length) && (length >= 0 && (length - 1 in obj || obj instanceof Array) || typeof obj.item === 'function');
}
- return copyElement(source, maxDepth);
+ /**
+ * @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 copyRecurse(source, destination, maxDepth) {
- maxDepth--;
- if (maxDepth < 0) {
- return '...';
- }
- var h = destination.$$hashKey;
- var key;
- if (isArray(source)) {
- for (var i = 0, ii = source.length; i < ii; i++) {
- destination.push(copyElement(source[i], maxDepth));
- }
- } else if (isBlankObject(source)) {
- // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
- for (key in source) {
- destination[key] = copyElement(source[key], maxDepth);
- }
- } else if (source && typeof source.hasOwnProperty === 'function') {
- // Slow path, which must rely on hasOwnProperty
- for (key in source) {
- if (source.hasOwnProperty(key)) {
- destination[key] = copyElement(source[key], maxDepth);
+ function forEach(obj, iterator, context) {
+ var key, length;
+ if (obj) {
+ if (isFunction(obj)) {
+ for (key in obj) {
+ if (key !== 'prototype' && key !== 'length' && key !== 'name' && obj.hasOwnProperty(key)) {
+ iterator.call(context, obj[key], key, obj);
+ }
}
- }
- } else {
- // Slowest path --- hasOwnProperty can't be called as a method
- for (key in source) {
- if (hasOwnProperty.call(source, key)) {
- destination[key] = copyElement(source[key], maxDepth);
+ } else if (isArray(obj) || isArrayLike(obj)) {
+ var isPrimitive = (typeof obj === 'undefined' ? 'undefined' : _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);
+ }
}
}
}
- setHashKey(destination, h);
- return destination;
+ return obj;
}
- function copyElement(source, maxDepth) {
- // Simple values
- if (!isObject(source)) {
- return source;
- }
-
- // Already copied values
- var index = stackSource.indexOf(source);
- if (index !== -1) {
- return stackDest[index];
- }
-
- if (isWindow(source) || isScope(source)) {
- throw ngMinErr('cpws',
- 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
- }
-
- var needsRecurse = false;
- var destination = copyType(source);
-
- if (destination === undefined) {
- destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
- needsRecurse = true;
+ 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;
+ }
- stackSource.push(source);
- stackDest.push(destination);
-
- return needsRecurse
- ? copyRecurse(source, destination, maxDepth)
- : destination;
+ /**
+ * 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);
+ };
}
- function copyType(source) {
- switch (toString.call(source)) {
- case '[object Int8Array]':
- case '[object Int16Array]':
- case '[object Int32Array]':
- case '[object Float32Array]':
- case '[object Float64Array]':
- case '[object Uint8Array]':
- case '[object Uint8ClampedArray]':
- case '[object Uint16Array]':
- case '[object Uint32Array]':
- return new source.constructor(copyElement(source.buffer), source.byteOffset, source.length);
+ /**
+ * 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;
+ }
- case '[object ArrayBuffer]':
- // Support: IE10
- if (!source.slice) {
- // If we're in this case we know the environment supports ArrayBuffer
- /* eslint-disable no-undef */
- var copied = new ArrayBuffer(source.byteLength);
- new Uint8Array(copied).set(new Uint8Array(source));
- /* eslint-enable */
- return copied;
+ /**
+ * 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 (src.nodeName) {
+ dst[key] = src.cloneNode(true);
+ } else if (isElement(src)) {
+ dst[key] = src.clone();
+ } else {
+ if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
+ baseExtend(dst[key], [src], true);
+ }
+ } else {
+ dst[key] = src;
}
- return source.slice(0);
-
- case '[object Boolean]':
- case '[object Number]':
- case '[object String]':
- case '[object Date]':
- return new source.constructor(source.valueOf());
-
- case '[object RegExp]':
- var re = new RegExp(source.source, source.toString().match(/[^/]*$/)[0]);
- re.lastIndex = source.lastIndex;
- return re;
-
- case '[object Blob]':
- return new source.constructor([source], {type: source.type});
+ }
}
- if (isFunction(source.cloneNode)) {
- return source.cloneNode(true);
- }
+ 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);
+ }
-// eslint-disable-next-line no-self-compare
-function simpleCompare(a, b) { return a === b || (a !== a && b !== b); }
+ function toInt(str) {
+ return parseInt(str, 10);
+ }
+ var isNumberNaN = Number.isNaN || function isNumberNaN(num) {
+ // eslint-disable-next-line no-self-compare
+ return num !== num;
+ };
-/**
- * @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.
- *
- * @example
-
-
-
-
-
- angular.module('equalsExample', []).controller('ExampleController', ['$scope', function($scope) {
- $scope.user1 = {};
- $scope.user2 = {};
- $scope.compare = function() {
- $scope.result = angular.equals($scope.user1, $scope.user2);
- };
- }]);
-
-
- */
-function equals(o1, o2) {
- if (o1 === o2) return true;
- if (o1 === null || o2 === null) return false;
- // eslint-disable-next-line no-self-compare
- if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
- var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
- if (t1 === t2 && 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 simpleCompare(o1.getTime(), o2.getTime());
- } else if (isRegExp(o1)) {
- if (!isRegExp(o2)) return false;
- return o1.toString() === o2.toString();
- } 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;
- }
+ /**
+ * @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);
+ };
+
+ // E.g.
+ function getResult(fn, input) {
+ return (fn || angular.identity)(input);
+ };
+
+ getResult(function(n) { return n * 2; }, 21); // returns 42
+ getResult(null, 21); // returns 21
+ getResult(undefined, 21); // returns 21
+ ```
+ *
+ * @param {*} value to be returned.
+ * @returns {*} the value passed in.
+ */
+ function identity($) {
+ return $;
}
- return false;
-}
+ identity.$inject = [];
-var csp = function() {
- if (!isDefined(csp.rules)) {
+ function valueFn(value) {
+ return function valueRef() {
+ return value;
+ };
+ }
+ function hasCustomToString(obj) {
+ return isFunction(obj.toString) && obj.toString !== toString;
+ }
- var ngCspElement = (window.document.querySelector('[ng-csp]') ||
- window.document.querySelector('[data-ng-csp]'));
+ /**
+ * @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';
+ }
- 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
- };
- }
+ /**
+ * @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';
}
- return csp.rules;
+ /**
+ * @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 === 'undefined' ? 'undefined' : _typeof(value)) === 'object';
+ }
- function noUnsafeEval() {
- try {
- // eslint-disable-next-line no-new, no-new-func
- new Function('');
- return false;
- } catch (e) {
- return true;
- }
+ /**
+ * 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 === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !getPrototypeOf(value);
}
-};
-/**
- * @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
-
-
- ...
- ...
-
- ```
- * @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
-
-
- ...
- ...
-
- ```
- */
-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];
- el = window.document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]');
- if (el) {
- name = el.getAttribute(prefix + 'jq');
- break;
- }
+ /**
+ * @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';
}
- return (jq.name_ = name);
-};
+ /**
+ * @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';
+ }
-function concat(array1, array2, index) {
- return array1.concat(slice.call(array2, index));
-}
+ /**
+ * @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]';
+ }
-function sliceArgs(args, startIndex) {
- return slice.call(args, startIndex || 0);
-}
+ /**
+ * @ngdoc function
+ * @name angular.isArray
+ * @module ng
+ * @kind function
+ *
+ * @description
+ * Determines if a reference is an `Array`. Alias of Array.isArray.
+ *
+ * @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';
+ }
-/**
- * @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.
- */
-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;
+ /**
+ * 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 toJsonReplacer(key, value) {
- var val = value;
+ function isScope(obj) {
+ return obj && obj.$evalAsync && obj.$watch;
+ }
- if (typeof key === 'string' && key.charAt(0) === '$' && key.charAt(1) === '$') {
- val = undefined;
- } else if (isWindow(value)) {
- val = '$WINDOW';
- } else if (value && window.document === value) {
- val = '$DOCUMENT';
- } else if (isScope(value)) {
- val = '$SCOPE';
+ function isFile(obj) {
+ return toString.call(obj) === '[object File]';
}
- return val;
-}
+ function isFormData(obj) {
+ return toString.call(obj) === '[object FormData]';
+ }
+ function isBlob(obj) {
+ return toString.call(obj) === '[object Blob]';
+ }
-/**
- * @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|boolean} 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`.
- * @knownIssue
- *
- * The Safari browser throws a `RangeError` instead of returning `null` when it tries to stringify a `Date`
- * object with an invalid date value. The only reliable way to prevent this is to monkeypatch the
- * `Date.prototype.toJSON` method as follows:
- *
- * ```
- * var _DatetoJSON = Date.prototype.toJSON;
- * Date.prototype.toJSON = function() {
- * try {
- * return _DatetoJSON.call(this);
- * } catch(e) {
- * if (e instanceof RangeError) {
- * return null;
- * }
- * throw e;
- * }
- * };
- * ```
- *
- * See https://github.com/angular/angular.js/pull/14221 for more information.
- */
-function toJson(obj, pretty) {
- if (isUndefined(obj)) return undefined;
- if (!isNumber(pretty)) {
- pretty = pretty ? 2 : null;
+ function isBoolean(value) {
+ return typeof value === 'boolean';
}
- return JSON.stringify(obj, toJsonReplacer, pretty);
-}
+ function isPromiseLike(obj) {
+ return obj && isFunction(obj.then);
+ }
-/**
- * @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;
-}
+ var TYPED_ARRAY_REGEXP = /^\[object (?:Uint8|Uint8Clamped|Uint16|Uint32|Int8|Int16|Int32|Float32|Float64)Array]$/;
+ function isTypedArray(value) {
+ return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
+ }
+ function isArrayBuffer(obj) {
+ return toString.call(obj) === '[object ArrayBuffer]';
+ }
-var ALL_COLONS = /:/g;
-function timezoneToOffset(timezone, fallback) {
- // Support: IE 9-11 only, Edge 13-14+
- // IE/Edge do not "understand" colon (`:`) in timezone
- timezone = timezone.replace(ALL_COLONS, '');
- var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
- return isNumberNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
-}
+ var trim = function trim(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 escapeForRegexp(s) {
+ return s.replace(/([-()[\]{}+?*.$^|,:#').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);
+ 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.
+ *
+ *
+ *
+ * Only enumerable properties are taken into account. Non-enumerable properties (both on `source`
+ * and on `destination`) will be ignored.
+ *
+ *
+ * @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
+
+
+
+
+
form = {{user | json}}
+
master = {{master | json}}
+
+ */
+ function copy(source, destination, maxDepth) {
+ var stackSource = [];
+ var stackDest = [];
+ maxDepth = isValidObjectMaxDepth(maxDepth) ? maxDepth : NaN;
+ if (destination) {
+ if (isTypedArray(destination) || isArrayBuffer(destination)) {
+ throw ngMinErr('cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
+ }
+ if (source === destination) {
+ throw ngMinErr('cpi', 'Can\'t copy! Source and destination are identical.');
+ }
-/////////////////////////////////////////////////
+ // Empty the destination object
+ if (isArray(destination)) {
+ destination.length = 0;
+ } else {
+ forEach(destination, function (value, key) {
+ if (key !== '$$hashKey') {
+ delete destination[key];
+ }
+ });
+ }
-/**
- * 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.
- }
-}
+ stackSource.push(source);
+ stackDest.push(destination);
+ return copyRecurse(source, destination, maxDepth);
+ }
+ return copyElement(source, maxDepth);
-/**
- * Parses an escaped url query string into key-value pairs.
- * @returns {Object.
}
- */
-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];
+ function copyRecurse(source, destination, maxDepth) {
+ maxDepth--;
+ if (maxDepth < 0) {
+ return '...';
+ }
+ var h = destination.$$hashKey;
+ var key;
+ if (isArray(source)) {
+ for (var i = 0, ii = source.length; i < ii; i++) {
+ destination.push(copyElement(source[i], maxDepth));
+ }
+ } else if (isBlankObject(source)) {
+ // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
+ for (key in source) {
+ destination[key] = copyElement(source[key], maxDepth);
+ }
+ } else if (source && typeof source.hasOwnProperty === 'function') {
+ // Slow path, which must rely on hasOwnProperty
+ for (key in source) {
+ if (source.hasOwnProperty(key)) {
+ destination[key] = copyElement(source[key], maxDepth);
+ }
+ }
+ } else {
+ // Slowest path --- hasOwnProperty can't be called as a method
+ for (key in source) {
+ if (hasOwnProperty.call(source, key)) {
+ destination[key] = copyElement(source[key], maxDepth);
+ }
}
}
+ setHashKey(destination, h);
+ return destination;
}
- });
- 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('&') : '';
-}
+ function copyElement(source, maxDepth) {
+ // Simple values
+ if (!isObject(source)) {
+ return source;
+ }
+ // Already copied values
+ var index = stackSource.indexOf(source);
+ if (index !== -1) {
+ return stackDest[index];
+ }
-/**
- * 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, '+');
-}
+ if (isWindow(source) || isScope(source)) {
+ throw ngMinErr('cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
+ }
+ var needsRecurse = false;
+ var destination = copyType(source);
-/**
- * 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' : '+'));
-}
+ if (destination === undefined) {
+ destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
+ needsRecurse = true;
+ }
-var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
+ stackSource.push(source);
+ stackDest.push(destination);
-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 needsRecurse ? copyRecurse(source, destination, maxDepth) : destination;
}
- }
- return null;
-}
-
-function allowAutoBootstrap(document) {
- var script = document.currentScript;
- if (!script) {
- // IE does not have `document.currentScript`
- return true;
- }
+ function copyType(source) {
+ switch (toString.call(source)) {
+ case '[object Int8Array]':
+ case '[object Int16Array]':
+ case '[object Int32Array]':
+ case '[object Float32Array]':
+ case '[object Float64Array]':
+ case '[object Uint8Array]':
+ case '[object Uint8ClampedArray]':
+ case '[object Uint16Array]':
+ case '[object Uint32Array]':
+ return new source.constructor(copyElement(source.buffer), source.byteOffset, source.length);
- // If the `currentScript` property has been clobbered just return false, since this indicates a probable attack
- if (!(script instanceof window.HTMLScriptElement || script instanceof window.SVGScriptElement)) {
- return false;
- }
+ case '[object ArrayBuffer]':
+ // Support: IE10
+ if (!source.slice) {
+ // If we're in this case we know the environment supports ArrayBuffer
+ /* eslint-disable no-undef */
+ var copied = new ArrayBuffer(source.byteLength);
+ new Uint8Array(copied).set(new Uint8Array(source));
+ /* eslint-enable */
+ return copied;
+ }
+ return source.slice(0);
- var attributes = script.attributes;
- var srcs = [attributes.getNamedItem('src'), attributes.getNamedItem('href'), attributes.getNamedItem('xlink:href')];
+ case '[object Boolean]':
+ case '[object Number]':
+ case '[object String]':
+ case '[object Date]':
+ return new source.constructor(source.valueOf());
- return srcs.every(function(src) {
- if (!src) {
- return true;
- }
- if (!src.value) {
- return false;
- }
+ case '[object RegExp]':
+ var re = new RegExp(source.source, source.toString().match(/[^/]*$/)[0]);
+ re.lastIndex = source.lastIndex;
+ return re;
- var link = document.createElement('a');
- link.href = src.value;
+ case '[object Blob]':
+ return new source.constructor([source], { type: source.type });
+ }
- if (document.location.origin === link.origin) {
- // Same-origin resources are always allowed, even for non-whitelisted schemes.
- return true;
+ if (isFunction(source.cloneNode)) {
+ return source.cloneNode(true);
+ }
}
- // Disabled bootstrapping unless angular.js was loaded from a known scheme used on the web.
- // This is to prevent angular.js bundled with browser extensions from being used to bypass the
- // content security policy in web pages and other browser extensions.
- switch (link.protocol) {
- case 'http:':
- case 'https:':
- case 'ftp:':
- case 'blob:':
- case 'file:':
- case 'data:':
+ }
+
+ // eslint-disable-next-line no-self-compare
+ function simpleCompare(a, b) {
+ return a === b || a !== a && b !== b;
+ }
+
+ /**
+ * @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.
+ *
+ * @example
+
+
+
+
+
+ angular.module('equalsExample', []).controller('ExampleController', ['$scope', function($scope) {
+ $scope.user1 = {};
+ $scope.user2 = {};
+ $scope.compare = function() {
+ $scope.result = angular.equals($scope.user1, $scope.user2);
+ };
+ }]);
+
+
+ */
+ function equals(o1, o2) {
+ if (o1 === o2) return true;
+ if (o1 === null || o2 === null) return false;
+ // eslint-disable-next-line no-self-compare
+ if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
+ var t1 = typeof o1 === 'undefined' ? 'undefined' : _typeof(o1),
+ t2 = typeof o2 === 'undefined' ? 'undefined' : _typeof(o2),
+ length,
+ key,
+ keySet;
+ if (t1 === t2 && 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 simpleCompare(o1.getTime(), o2.getTime());
+ } else if (isRegExp(o1)) {
+ if (!isRegExp(o2)) return false;
+ return o1.toString() === o2.toString();
+ } 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;
- default:
- return false;
+ }
}
- });
-}
+ return false;
+ }
-// Cached as it has to run during loading so that document.currentScript is available.
-var isAutoBootstrapAllowed = allowAutoBootstrap(window.document);
+ var csp = function csp() {
+ if (!isDefined(csp.rules)) {
-/**
- * @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 `` or `` tags.
- *
- * There are a few things to keep in mind when using `ngApp`:
- * - 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.
- * - Do not use a directive that uses {@link ng.$compile#transclusion transclusion} on the same element as `ngApp`.
- * This includes directives such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and
- * {@link ngRoute.ngView `ngView`}.
- * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
- * causing animations to stop working and making the injector inaccessible from outside the app.
- *
- * 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.
- *
-
-
-
- I can add: {{a}} + {{b}} = {{ a+b }}
-
-
-
- angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
- $scope.a = 1;
- $scope.b = 2;
- });
-
-
- *
- * Using `ngStrictDi`, you would see something like this:
- *
-
-
-
-
- I can add: {{a}} + {{b}} = {{ a+b }}
-
-
This renders because the controller does not fail to
- instantiate, by using explicit annotation style (see
- script.js for details)
-
-
+ var ngCspElement = window.document.querySelector('[ng-csp]') || window.document.querySelector('[data-ng-csp]');
-
- Name:
- Hello, {{name}}!
+ 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
+ };
+ }
+ }
-
This renders because the controller does not fail to
- instantiate, by using explicit annotation style
- (see script.js for details)
-
-
+ return csp.rules;
-
- I can add: {{a}} + {{b}} = {{ a+b }}
+ function noUnsafeEval() {
+ try {
+ // eslint-disable-next-line no-new, no-new-func
+ new Function('');
+ return false;
+ } catch (e) {
+ return true;
+ }
+ }
+ };
-
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.
-
-
-
').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);
+ }
+ }
-var bindJQueryFired = false;
-function bindJQuery() {
- var originalCleanData;
+ /////////////////////////////////////////////////
- if (bindJQueryFired) {
- return;
+ /**
+ * 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.
+ }
}
- // 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: /** @type {?} */ (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;
- for (var i = 0, elem; (elem = elems[i]) != null; i++) {
- events = jQuery._data(elem, 'events');
- if (events && events.$destroy) {
- jQuery(elem).triggerHandler('$destroy');
+ /**
+ * Parses an escaped url query string into key-value pairs.
+ * @returns {Object.
}
+ */
+ 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];
+ }
}
}
- originalCleanData(elems);
- };
- } else {
- jqLite = JQLite;
+ });
+ return obj;
}
- angular.element = jqLite;
-
- // Prevent double-proxying.
- bindJQueryFired = true;
-}
+ 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('&') : '';
+ }
-/**
- * throw error if the argument is falsy.
- */
-function assertArg(arg, name, reason) {
- if (!arg) {
- throw ngMinErr('areq', 'Argument \'{0}\' is {1}', (name || '?'), (reason || 'required'));
+ /**
+ * 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, '+');
}
- return arg;
-}
-function assertArgFn(arg, name, acceptArrayAnnotation) {
- if (acceptArrayAnnotation && isArray(arg)) {
- arg = arg[arg.length - 1];
+ /**
+ * 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' : '+');
}
- assertArg(isFunction(arg), name, 'not a function, got ' +
- (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));
- return arg;
-}
+ var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
-/**
- * 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);
+ 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;
}
-}
-/**
- * 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;
+ function allowAutoBootstrap(document) {
+ var script = document.currentScript;
- for (var i = 0; i < len; i++) {
- key = keys[i];
- if (obj) {
- obj = (lastInstance = obj)[key];
+ if (!script) {
+ // IE does not have `document.currentScript`
+ return true;
}
+
+ // If the `currentScript` property has been clobbered just return false, since this indicates a probable attack
+ if (!(script instanceof window.HTMLScriptElement || script instanceof window.SVGScriptElement)) {
+ return false;
+ }
+
+ var attributes = script.attributes;
+ var srcs = [attributes.getNamedItem('src'), attributes.getNamedItem('href'), attributes.getNamedItem('xlink:href')];
+
+ return srcs.every(function (src) {
+ if (!src) {
+ return true;
+ }
+ if (!src.value) {
+ return false;
+ }
+
+ var link = document.createElement('a');
+ link.href = src.value;
+
+ if (document.location.origin === link.origin) {
+ // Same-origin resources are always allowed, even for non-whitelisted schemes.
+ return true;
+ }
+ // Disabled bootstrapping unless angular.js was loaded from a known scheme used on the web.
+ // This is to prevent angular.js bundled with browser extensions from being used to bypass the
+ // content security policy in web pages and other browser extensions.
+ switch (link.protocol) {
+ case 'http:':
+ case 'https:':
+ case 'ftp:':
+ case 'blob:':
+ case 'file:':
+ case 'data:':
+ return true;
+ default:
+ return false;
+ }
+ });
}
- 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;
+ // Cached as it has to run during loading so that document.currentScript is available.
+ var isAutoBootstrapAllowed = allowAutoBootstrap(window.document);
+
+ /**
+ * @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 `` or `` tags.
+ *
+ * There are a few things to keep in mind when using `ngApp`:
+ * - 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.
+ * - Do not use a directive that uses {@link ng.$compile#transclusion transclusion} on the same element as `ngApp`.
+ * This includes directives such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and
+ * {@link ngRoute.ngView `ngView`}.
+ * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
+ * causing animations to stop working and making the injector inaccessible from outside the app.
+ *
+ * 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.
+ *
+
+
+
+ I can add: {{a}} + {{b}} = {{ a+b }}
+
+
+
+ angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
+ $scope.a = 1;
+ $scope.b = 2;
+ });
+
+
+ *
+ * Using `ngStrictDi`, you would see something like this:
+ *
+
+
+
+
+ I can add: {{a}} + {{b}} = {{ a+b }}
+
+
This renders because the controller does not fail to
+ instantiate, by using explicit annotation style (see
+ script.js for details)
+
+
+
+
+ Name:
+ Hello, {{name}}!
+
+
This renders because the controller does not fail to
+ instantiate, by using explicit annotation style
+ (see script.js for details)
+
+
+
+
+ I can add: {{a}} + {{b}} = {{ a+b }}
+
+
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.
+
+
+
- * **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`).
- *
- */
- filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
+ var $injectorMinErr = minErr('$injector');
+ var ngMinErr = minErr('ng');
- /**
- * @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'),
+ function ensure(obj, name, factory) {
+ return obj[name] || (obj[name] = factory());
+ }
- /**
- * @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'),
+ var angular = ensure(window, 'angular', Object);
- /**
- * @ngdoc method
- * @name angular.Module#component
- * @module ng
- * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
- * @param {Object} options Component definition object (a simplified
- * {@link ng.$compile#directive-definition-object directive definition object})
- *
- * @description
- * See {@link ng.$compileProvider#component $compileProvider.component()}.
- */
- component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
+ // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
+ angular.$$minErr = angular.$$minErr || minErr;
- /**
- * @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,
+ return ensure(angular, 'module', function () {
+ /** @type {Object.} */
+ var modules = {};
- /**
- * @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;
+ /**
+ * @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.=} 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 {angular.Module} new module with the {@link angular.Module} api.
+ */
+ return function module(name, requires, configFn) {
+
+ var _info = {};
+
+ var assertNotHasOwnProperty = function assertNotHasOwnProperty(name, context) {
+ if (name === 'hasOwnProperty') {
+ throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
}
};
- if (configFn) {
- config(configFn);
+ 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);
+ }
- return moduleInstance;
+ /** @type {!Array.>} */
+ var invokeQueue = [];
+
+ /** @type {!Array.} */
+ var configBlocks = [];
+
+ /** @type {!Array.} */
+ var runBlocks = [];
+
+ var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
+
+ /** @type {angular.Module} */
+ var moduleInstance = {
+ // Private state
+ _invokeQueue: invokeQueue,
+ _configBlocks: configBlocks,
+ _runBlocks: runBlocks,
+
+ /**
+ * @ngdoc method
+ * @name angular.Module#info
+ * @module ng
+ *
+ * @param {Object=} info Information about the module
+ * @returns {Object|Module} The current info object for this module if called as a getter,
+ * or `this` if called as a setter.
+ *
+ * @description
+ * Read and write custom information about this module.
+ * For example you could put the version of the module in here.
+ *
+ * ```js
+ * angular.module('myModule', []).info({ version: '1.0.0' });
+ * ```
+ *
+ * The version could then be read back out by accessing the module elsewhere:
+ *
+ * ```
+ * var version = angular.module('myModule').info().version;
+ * ```
+ *
+ * You can also retrieve this information during runtime via the
+ * {@link $injector#modules `$injector.modules`} property:
+ *
+ * ```js
+ * var version = $injector.modules['myModule'].info().version;
+ * ```
+ */
+ info: function info(value) {
+ if (isDefined(value)) {
+ if (!isObject(value)) throw ngMinErr('aobj', 'Argument \'{0}\' must be an object', 'value');
+ _info = value;
+ return this;
+ }
+ return _info;
+ },
- /**
- * @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;
+ /**
+ * @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 constants 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} name The name of the service to decorate.
+ * @param {Function} decorFn 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', configBlocks),
+
+ /**
+ * @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()}.
+ *
+ *
+ * **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`).
+ *
+ */
+ 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#component
+ * @module ng
+ * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
+ * @param {Object} options Component definition object (a simplified
+ * {@link ng.$compile#directive-definition-object directive definition object})
+ *
+ * @description
+ * See {@link ng.$compileProvider#component $compileProvider.component()}.
+ */
+ component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
+
+ /**
+ * @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 run(block) {
+ runBlocks.push(block);
+ return this;
+ }
};
- }
- /**
- * @param {string} provider
- * @param {string} method
- * @returns {angular.Module}
- */
- function invokeLaterAndSetModuleName(provider, method, queue) {
- if (!queue) queue = invokeQueue;
- return function(recipeName, factoryFunction) {
- if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
- queue.push([provider, method, arguments]);
- return moduleInstance;
- };
- }
- });
- };
- });
+ if (configFn) {
+ config(configFn);
+ }
-}
+ return moduleInstance;
-/* global shallowCopy: true */
+ /**
+ * @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;
+ };
+ }
-/**
- * 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 || [];
+ /**
+ * @param {string} provider
+ * @param {string} method
+ * @returns {angular.Module}
+ */
+ function invokeLaterAndSetModuleName(provider, method, queue) {
+ if (!queue) queue = invokeQueue;
+ return function (recipeName, factoryFunction) {
+ if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
+ queue.push([provider, method, arguments]);
+ return moduleInstance;
+ };
+ }
+ });
+ };
+ });
+ }
- for (var i = 0, ii = src.length; i < ii; i++) {
- dst[i] = src[i];
- }
- } else if (isObject(src)) {
- dst = dst || {};
+ /* global shallowCopy: true */
+
+ /**
+ * 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];
+ for (var key in src) {
+ if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) {
+ dst[key] = src[key];
+ }
}
}
+
+ return dst || src;
}
- return dst || src;
-}
+ /* global toDebugString: true */
+
+ function serializeObject(obj, maxDepth) {
+ var seen = [];
-/* global toDebugString: true */
+ // There is no direct way to stringify object until reaching a specific depth
+ // and a very deep object can cause a performance issue, so we copy the object
+ // based on this specific depth and then stringify it.
+ if (isValidObjectMaxDepth(maxDepth)) {
+ obj = copy(obj, null, maxDepth);
+ }
+ return JSON.stringify(obj, function (key, val) {
+ val = toJsonReplacer(key, val);
+ if (isObject(val)) {
-function serializeObject(obj, maxDepth) {
- var seen = [];
+ if (seen.indexOf(val) >= 0) return '...';
- // There is no direct way to stringify object until reaching a specific depth
- // and a very deep object can cause a performance issue, so we copy the object
- // based on this specific depth and then stringify it.
- if (isValidObjectMaxDepth(maxDepth)) {
- obj = copy(obj, null, maxDepth);
+ seen.push(val);
+ }
+ return val;
+ });
}
- return JSON.stringify(obj, function(key, val) {
- val = toJsonReplacer(key, val);
- if (isObject(val)) {
-
- if (seen.indexOf(val) >= 0) return '...';
- seen.push(val);
+ function toDebugString(obj, maxDepth) {
+ if (typeof obj === 'function') {
+ return obj.toString().replace(/ \{[\s\S]*$/, '');
+ } else if (isUndefined(obj)) {
+ return 'undefined';
+ } else if (typeof obj !== 'string') {
+ return serializeObject(obj, maxDepth);
}
- return val;
- });
-}
+ return obj;
+ }
-function toDebugString(obj, maxDepth) {
- if (typeof obj === 'function') {
- return obj.toString().replace(/ \{[\s\S]*$/, '');
- } else if (isUndefined(obj)) {
- return 'undefined';
- } else if (typeof obj !== 'string') {
- return serializeObject(obj, maxDepth);
- }
- return obj;
-}
-
-/* global angularModule: true,
- version: true,
-
- $CompileProvider,
-
- htmlAnchorDirective,
- inputDirective,
- inputDirective,
- formDirective,
- scriptDirective,
- selectDirective,
- 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,
- $$CoreAnimateJsProvider,
- $$CoreAnimateQueueProvider,
- $$AnimateRunnerFactoryProvider,
- $$AnimateAsyncRunFactoryProvider,
- $BrowserProvider,
- $CacheFactoryProvider,
- $ControllerProvider,
- $DateProvider,
- $DocumentProvider,
- $$IsDocumentHiddenProvider,
- $ExceptionHandlerProvider,
- $FilterProvider,
- $$ForceReflowProvider,
- $InterpolateProvider,
- $IntervalProvider,
- $HttpProvider,
- $HttpParamSerializerProvider,
- $HttpParamSerializerJQLikeProvider,
- $HttpBackendProvider,
- $xhrFactoryProvider,
- $jsonpCallbacksProvider,
- $LocationProvider,
- $LogProvider,
- $$MapProvider,
- $ParseProvider,
- $RootScopeProvider,
- $QProvider,
- $$QProvider,
- $$SanitizeUriProvider,
- $SceProvider,
- $SceDelegateProvider,
- $SnifferProvider,
- $TemplateCacheProvider,
- $TemplateRequestProvider,
- $$TestabilityProvider,
- $TimeoutProvider,
- $$RAFProvider,
- $WindowProvider,
- $$jqLiteProvider,
- $$CookieReaderProvider
-*/
+ /* global angularModule: true,
+ version: true,
+
+ $CompileProvider,
+
+ htmlAnchorDirective,
+ inputDirective,
+ inputDirective,
+ formDirective,
+ scriptDirective,
+ selectDirective,
+ 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,
+ $$CoreAnimateJsProvider,
+ $$CoreAnimateQueueProvider,
+ $$AnimateRunnerFactoryProvider,
+ $$AnimateAsyncRunFactoryProvider,
+ $BrowserProvider,
+ $CacheFactoryProvider,
+ $ControllerProvider,
+ $DateProvider,
+ $DocumentProvider,
+ $$IsDocumentHiddenProvider,
+ $ExceptionHandlerProvider,
+ $FilterProvider,
+ $$ForceReflowProvider,
+ $InterpolateProvider,
+ $IntervalProvider,
+ $HttpProvider,
+ $HttpParamSerializerProvider,
+ $HttpParamSerializerJQLikeProvider,
+ $HttpBackendProvider,
+ $xhrFactoryProvider,
+ $jsonpCallbacksProvider,
+ $LocationProvider,
+ $LogProvider,
+ $$MapProvider,
+ $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 = {
+ // These placeholder strings will be replaced by grunt's `build` task.
+ // They need to be double- or single-quoted.
+ full: '1.6.4',
+ major: 1,
+ minor: 6,
+ dot: 4,
+ codeName: 'phenomenal-footnote'
+ };
-/**
- * @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 = {
- // These placeholder strings will be replaced by grunt's `build` task.
- // They need to be double- or single-quoted.
- full: '1.6.4',
- major: 1,
- minor: 6,
- dot: 4,
- codeName: 'phenomenal-footnote'
-};
-
-
-function publishExternalAPI(angular) {
- extend(angular, {
- 'errorHandlingConfig': errorHandlingConfig,
- '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,
- 'reloadWithDebugInfo': reloadWithDebugInfo,
- '$$minErr': minErr,
- '$$csp': csp,
- '$$encodeUriSegment': encodeUriSegment,
- '$$encodeUriQuery': encodeUriQuery,
- '$$stringify': stringify
- });
+ function publishExternalAPI(angular) {
+ extend(angular, {
+ 'errorHandlingConfig': errorHandlingConfig,
+ '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,
+ 'reloadWithDebugInfo': reloadWithDebugInfo,
+ '$$minErr': minErr,
+ '$$csp': csp,
+ '$$encodeUriSegment': encodeUriSegment,
+ '$$encodeUriQuery': encodeUriQuery,
+ '$$stringify': stringify
+ });
- angularModule = setupModuleLoader(window);
+ angularModule = setupModuleLoader(window);
- angularModule('ng', ['ngLocale'], ['$provide',
- function ngModule($provide) {
+ 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,
- 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('$compile', $CompileProvider).directive({
+ a: htmlAnchorDirective,
+ input: inputDirective,
+ textarea: inputDirective,
+ form: formDirective,
+ script: scriptDirective,
+ select: selectDirective,
+ 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,
@@ -32380,17063 +28217,16700 @@ function publishExternalAPI(angular) {
$$Map: $$MapProvider,
$$cookieReader: $$CookieReaderProvider
});
- }
- ])
- .info({ angularVersion: '1.6.4' });
-}
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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,
- BOOLEAN_ATTR: true,
- ALIASED_ATTR: true
-*/
+ }]).info({ angularVersion: '1.6.4' });
+ }
-//////////////////////////////////
-//JQLite
-//////////////////////////////////
+ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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? *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/**
- * @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**.
- *
- * 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.
- *
- * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
- * {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
- * specific version of jQuery if multiple versions exist on the page.
- *
- * **Note:** All element references in Angular are always wrapped with jQuery or
- * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.
- *
- * **Note:** Keep in mind that this function will not find elements
- * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
- * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.
- *
- * ## Angular's jqLite
- * jqLite provides only the following jQuery methods:
- *
- * - [`addClass()`](http://api.jquery.com/addClass/) - Does not support a function as first argument
- * - [`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/) (_deprecated_, use [`on()`](http://api.jquery.com/on/)) - 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', and also does not have automatic property prefixing.
- * - [`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/) (_deprecated_, use `angular.element(callback)` instead of `angular.element(document).ready(callback)`)
- * - [`remove()`](http://api.jquery.com/remove/)
- * - [`removeAttr()`](http://api.jquery.com/removeAttr/) - Does not support multiple attributes
- * - [`removeClass()`](http://api.jquery.com/removeClass/) - Does not support a function as first argument
- * - [`removeData()`](http://api.jquery.com/removeData/)
- * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
- * - [`text()`](http://api.jquery.com/text/)
- * - [`toggleClass()`](http://api.jquery.com/toggleClass/) - Does not support a function as first argument
- * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers
- * - [`unbind()`](http://api.jquery.com/unbind/) (_deprecated_, use [`off()`](http://api.jquery.com/off/)) - 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.
- *
- * @knownIssue You cannot spy on `angular.element` if you are using Jasmine version 1.x. See
- * https://github.com/angular/angular.js/issues/14251 for more information.
- *
- * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
- * @returns {Object} jQuery object.
- */
+ /* global
+ JQLitePrototype: true,
+ BOOLEAN_ATTR: true,
+ ALIASED_ATTR: true
+ */
-JQLite.expando = 'ng339';
+ //////////////////////////////////
+ //JQLite
+ //////////////////////////////////
-var jqCache = JQLite.cache = {},
- jqId = 1;
+ /**
+ * @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**.
+ *
+ * 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.
+ *
+ * To use `jQuery`, simply ensure it is loaded before the `angular.js` file. You can also use the
+ * {@link ngJq `ngJq`} directive to specify that jqlite should be used over jQuery, or to use a
+ * specific version of jQuery if multiple versions exist on the page.
+ *
+ * **Note:** All element references in Angular are always wrapped with jQuery or
+ * jqLite (such as the element argument in a directive's compile / link function). They are never raw DOM references.
+ *
+ * **Note:** Keep in mind that this function will not find elements
+ * by tag name / CSS selector. For lookups by tag name, try instead `angular.element(document).find(...)`
+ * or `$document.find()`, or use the standard DOM APIs, e.g. `document.querySelectorAll()`.
+ *
+ * ## Angular's jqLite
+ * jqLite provides only the following jQuery methods:
+ *
+ * - [`addClass()`](http://api.jquery.com/addClass/) - Does not support a function as first argument
+ * - [`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/) (_deprecated_, use [`on()`](http://api.jquery.com/on/)) - 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', and also does not have automatic property prefixing.
+ * - [`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/) (_deprecated_, use `angular.element(callback)` instead of `angular.element(document).ready(callback)`)
+ * - [`remove()`](http://api.jquery.com/remove/)
+ * - [`removeAttr()`](http://api.jquery.com/removeAttr/) - Does not support multiple attributes
+ * - [`removeClass()`](http://api.jquery.com/removeClass/) - Does not support a function as first argument
+ * - [`removeData()`](http://api.jquery.com/removeData/)
+ * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
+ * - [`text()`](http://api.jquery.com/text/)
+ * - [`toggleClass()`](http://api.jquery.com/toggleClass/) - Does not support a function as first argument
+ * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers
+ * - [`unbind()`](http://api.jquery.com/unbind/) (_deprecated_, use [`off()`](http://api.jquery.com/off/)) - 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.
+ *
+ * @knownIssue You cannot spy on `angular.element` if you are using Jasmine version 1.x. See
+ * https://github.com/angular/angular.js/issues/14251 for more information.
+ *
+ * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
+ * @returns {Object} jQuery object.
+ */
-/*
- * !!! This is an undocumented "private" function !!!
- */
-JQLite._data = function(node) {
- //jQuery always returns an object on cache miss
- return this.cache[node[this.expando]] || {};
-};
+ JQLite.expando = 'ng339';
-function jqNextId() { return ++jqId; }
+ var jqCache = JQLite.cache = {},
+ jqId = 1;
+ /*
+ * !!! This is an undocumented "private" function !!!
+ */
+ JQLite._data = function (node) {
+ //jQuery always returns an object on cache miss
+ return this.cache[node[this.expando]] || {};
+ };
-var DASH_LOWERCASE_REGEXP = /-([a-z])/g;
-var MS_HACK_REGEXP = /^-ms-/;
-var MOUSE_EVENT_MAP = { mouseleave: 'mouseout', mouseenter: 'mouseover' };
-var jqLiteMinErr = minErr('jqLite');
+ function jqNextId() {
+ return ++jqId;
+ }
-/**
- * Converts kebab-case to camelCase.
- * There is also a special case for the ms prefix starting with a lowercase letter.
- * @param name Name to normalize
- */
-function cssKebabToCamel(name) {
- return kebabToCamel(name.replace(MS_HACK_REGEXP, 'ms-'));
-}
+ var DASH_LOWERCASE_REGEXP = /-([a-z])/g;
+ var MS_HACK_REGEXP = /^-ms-/;
+ var MOUSE_EVENT_MAP = { mouseleave: 'mouseout', mouseenter: 'mouseover' };
+ var jqLiteMinErr = minErr('jqLite');
-function fnCamelCaseReplace(all, letter) {
- return letter.toUpperCase();
-}
+ /**
+ * Converts kebab-case to camelCase.
+ * There is also a special case for the ms prefix starting with a lowercase letter.
+ * @param name Name to normalize
+ */
+ function cssKebabToCamel(name) {
+ return kebabToCamel(name.replace(MS_HACK_REGEXP, 'ms-'));
+ }
-/**
- * Converts kebab-case to camelCase.
- * @param name Name to normalize
- */
-function kebabToCamel(name) {
- return name
- .replace(DASH_LOWERCASE_REGEXP, fnCamelCaseReplace);
-}
+ function fnCamelCaseReplace(all, letter) {
+ return letter.toUpperCase();
+ }
-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;
+ /**
+ * Converts kebab-case to camelCase.
+ * @param name Name to normalize
+ */
+ function kebabToCamel(name) {
+ return name.replace(DASH_LOWERCASE_REGEXP, fnCamelCaseReplace);
+ }
-var wrapMap = {
- 'option': [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;
- 'thead': [1, ''],
- 'col': [2, ''],
- 'tr': [2, ''],
- 'td': [3, ''],
- '_default': [0, '', '']
-};
+ var wrapMap = {
+ 'option': [1, ''],
-wrapMap.optgroup = wrapMap.option;
-wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
-wrapMap.th = wrapMap.td;
+ 'thead': [1, ''],
+ 'col': [2, ''],
+ 'tr': [2, ''],
+ 'td': [3, ''],
+ '_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 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 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;
+ function jqLiteHasData(node) {
+ for (var key in jqCache[node.ng339]) {
+ return true;
+ }
+ return false;
}
- return false;
-}
-function jqLiteBuildFragment(html, context) {
- var tmp, tag, wrap,
- fragment = context.createDocumentFragment(),
- nodes = [], i;
+ 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 = 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>') + wrap[2];
-
- // Descend through wrappers to the right content
- i = wrap[0];
- while (i--) {
- tmp = tmp.lastChild;
+ if (jqLiteIsTextNode(html)) {
+ // Convert non-html into a text node
+ nodes.push(context.createTextNode(html));
+ } else {
+ // Convert html into DOM nodes
+ 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>') + 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 = '';
}
- nodes = concat(nodes, tmp.childNodes);
+ // Remove wrapper from fragment
+ fragment.textContent = '';
+ fragment.innerHTML = ''; // Clear inner HTML
+ forEach(nodes, function (node) {
+ fragment.appendChild(node);
+ });
- tmp = fragment.firstChild;
- tmp.textContent = '';
+ return fragment;
}
- // 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 || window.document;
+ var parsed;
-function jqLiteParseHTML(html, context) {
- context = context || window.document;
- var parsed;
+ if (parsed = SINGLE_TAG_REGEXP.exec(html)) {
+ return [context.createElement(parsed[1])];
+ }
- if ((parsed = SINGLE_TAG_REGEXP.exec(html))) {
- return [context.createElement(parsed[1])];
- }
+ if (parsed = jqLiteBuildFragment(html, context)) {
+ return parsed.childNodes;
+ }
- if ((parsed = jqLiteBuildFragment(html, context))) {
- return parsed.childNodes;
+ return [];
}
- return [];
-}
+ function jqLiteWrapNode(node, wrapper) {
+ var parent = node.parentNode;
-function jqLiteWrapNode(node, wrapper) {
- var parent = node.parentNode;
+ if (parent) {
+ parent.replaceChild(wrapper, node);
+ }
- if (parent) {
- parent.replaceChild(wrapper, node);
+ wrapper.appendChild(node);
}
- wrapper.appendChild(node);
-}
-
+ // IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
+ var jqLiteContains = window.Node.prototype.contains || /** @this */function (arg) {
+ // eslint-disable-next-line no-bitwise
+ return !!(this.compareDocumentPosition(arg) & 16);
+ };
-// IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
-var jqLiteContains = window.Node.prototype.contains || /** @this */ function(arg) {
- // eslint-disable-next-line no-bitwise
- return !!(this.compareDocumentPosition(arg) & 16);
-};
+ /////////////////////////////////////////////
+ function JQLite(element) {
+ if (element instanceof JQLite) {
+ return element;
+ }
-/////////////////////////////////////////////
-function JQLite(element) {
- if (element instanceof JQLite) {
- return element;
- }
+ var argIsString;
- 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 (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');
+ if (argIsString) {
+ jqLiteAddNodes(this, jqLiteParseHTML(element));
+ } else if (isFunction(element)) {
+ jqLiteReady(element);
+ } else {
+ jqLiteAddNodes(this, element);
}
- return new JQLite(element);
}
- if (argIsString) {
- jqLiteAddNodes(this, jqLiteParseHTML(element));
- } else if (isFunction(element)) {
- jqLiteReady(element);
- } else {
- jqLiteAddNodes(this, element);
+ function jqLiteClone(element) {
+ return element.cloneNode(true);
}
-}
-
-function jqLiteClone(element) {
- return element.cloneNode(true);
-}
-function jqLiteDealoc(element, onlyDescendants) {
- if (!onlyDescendants && jqLiteAcceptsData(element)) jqLite.cleanData([element]);
+ function jqLiteDealoc(element, onlyDescendants) {
+ if (!onlyDescendants && jqLiteAcceptsData(element)) jqLite.cleanData([element]);
- if (element.querySelectorAll) {
- jqLite.cleanData(element.querySelectorAll('*'));
+ if (element.querySelectorAll) {
+ jqLite.cleanData(element.querySelectorAll('*'));
+ }
}
-}
-
-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;
+ function jqLiteOff(element, type, fn, unsupported) {
+ if (isDefined(unsupported)) throw jqLiteMinErr('offargs', 'jqLite#off() does not support the `selector` argument');
- if (!handle) return; //no listeners registered
+ var expandoStore = jqLiteExpandoStore(element);
+ var events = expandoStore && expandoStore.events;
+ var handle = expandoStore && expandoStore.handle;
- if (!type) {
- for (type in events) {
- if (type !== '$destroy') {
- element.removeEventListener(type, handle);
- }
- delete events[type];
- }
- } else {
+ if (!handle) return; //no listeners registered
- var removeHandler = function(type) {
- var listenerFns = events[type];
- if (isDefined(fn)) {
- arrayRemove(listenerFns || [], fn);
- }
- if (!(isDefined(fn) && listenerFns && listenerFns.length > 0)) {
- element.removeEventListener(type, handle);
+ if (!type) {
+ for (type in events) {
+ if (type !== '$destroy') {
+ element.removeEventListener(type, handle);
+ }
delete events[type];
}
- };
+ } else {
- forEach(type.split(' '), function(type) {
- removeHandler(type);
- if (MOUSE_EVENT_MAP[type]) {
- removeHandler(MOUSE_EVENT_MAP[type]);
- }
- });
+ var removeHandler = function removeHandler(type) {
+ var listenerFns = events[type];
+ if (isDefined(fn)) {
+ arrayRemove(listenerFns || [], fn);
+ }
+ if (!(isDefined(fn) && listenerFns && listenerFns.length > 0)) {
+ element.removeEventListener(type, handle);
+ delete events[type];
+ }
+ };
+
+ forEach(type.split(' '), function (type) {
+ removeHandler(type);
+ if (MOUSE_EVENT_MAP[type]) {
+ removeHandler(MOUSE_EVENT_MAP[type]);
+ }
+ });
+ }
}
-}
-function jqLiteRemoveData(element, name) {
- var expandoId = element.ng339;
- var expandoStore = expandoId && jqCache[expandoId];
+ function jqLiteRemoveData(element, name) {
+ var expandoId = element.ng339;
+ var expandoStore = expandoId && jqCache[expandoId];
- if (expandoStore) {
- if (name) {
- delete expandoStore.data[name];
- return;
- }
+ if (expandoStore) {
+ if (name) {
+ delete expandoStore.data[name];
+ return;
+ }
- if (expandoStore.handle) {
- if (expandoStore.events.$destroy) {
- expandoStore.handle({}, '$destroy');
+ if (expandoStore.handle) {
+ if (expandoStore.events.$destroy) {
+ expandoStore.handle({}, '$destroy');
+ }
+ jqLiteOff(element);
}
- jqLiteOff(element);
+ delete jqCache[expandoId];
+ element.ng339 = undefined; // don't delete DOM expandos. IE and Chrome don't like it
}
- 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];
-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 };
+ }
- if (createIfNecessary && !expandoStore) {
- element.ng339 = expandoId = jqNextId();
- expandoStore = jqCache[expandoId] = {events: {}, data: {}, handle: undefined};
+ return expandoStore;
}
- return expandoStore;
-}
-
+ function jqLiteData(element, key, value) {
+ if (jqLiteAcceptsData(element)) {
+ var prop;
-function jqLiteData(element, key, value) {
- if (jqLiteAcceptsData(element)) {
- var prop;
+ var isSimpleSetter = isDefined(value);
+ var isSimpleGetter = !isSimpleSetter && key && !isObject(key);
+ var massGetter = !key;
+ var expandoStore = jqLiteExpandoStore(element, !isSimpleGetter);
+ var data = expandoStore && expandoStore.data;
- 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[kebabToCamel(key)] = value;
- } else {
- if (massGetter) { // data()
- return data;
+ if (isSimpleSetter) {
+ // data('key', value)
+ data[kebabToCamel(key)] = value;
} else {
- if (isSimpleGetter) { // data('key')
- // don't force creation of expandoStore if it doesn't exist yet
- return data && data[kebabToCamel(key)];
- } else { // mass-setter: data({key1: val1, key2: val2})
- for (prop in key) {
- data[kebabToCamel(prop)] = key[prop];
+ 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[kebabToCamel(key)];
+ } else {
+ // mass-setter: data({key1: val1, key2: val2})
+ for (prop in key) {
+ data[kebabToCamel(prop)] = key[prop];
+ }
}
}
}
}
}
-}
-function jqLiteHasClass(element, selector) {
- if (!element.getAttribute) return false;
- return ((' ' + (element.getAttribute('class') || '') + ' ').replace(/[\n\t]/g, ' ').
- indexOf(' ' + selector + ' ') > -1);
-}
+ 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 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, ' ');
+ 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 + ' ';
- }
- });
+ forEach(cssClasses.split(' '), function (cssClass) {
+ cssClass = trim(cssClass);
+ if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) {
+ existingClasses += cssClass + ' ';
+ }
+ });
- element.setAttribute('class', trim(existingClasses));
+ element.setAttribute('class', trim(existingClasses));
+ }
}
-}
-
-function jqLiteAddNodes(root, elements) {
- // THIS CODE IS VERY HOT. Don't make changes without benchmarking.
+ function jqLiteAddNodes(root, elements) {
+ // THIS CODE IS VERY HOT. Don't make changes without benchmarking.
- if (elements) {
+ if (elements) {
- // if a Node (the most common case)
- if (elements.nodeType) {
- root[root.length++] = elements;
- } else {
- var length = elements.length;
+ // 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];
+ // 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;
}
- } 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;
+ function jqLiteController(element, name) {
+ return jqLiteInheritedData(element, '$' + (name || 'ngController') + 'Controller');
}
- 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;
+ 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];
- // 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);
- }
-}
+ while (element) {
+ for (var i = 0, ii = names.length; i < ii; i++) {
+ if (isDefined(value = jqLite.data(element, names[i]))) return value;
+ }
-function jqLiteEmpty(element) {
- jqLiteDealoc(element, true);
- while (element.firstChild) {
- element.removeChild(element.firstChild);
+ // 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 jqLiteRemove(element, keepData) {
- if (!keepData) jqLiteDealoc(element);
- var parent = element.parentNode;
- if (parent) parent.removeChild(element);
-}
+ function jqLiteEmpty(element) {
+ jqLiteDealoc(element, true);
+ while (element.firstChild) {
+ element.removeChild(element.firstChild);
+ }
+ }
-function jqLiteDocumentLoaded(action, win) {
- win = win || window;
- if (win.document.readyState === 'complete') {
- // Force the action to be run async for consistent behavior
- // 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);
+ function jqLiteRemove(element, keepData) {
+ if (!keepData) jqLiteDealoc(element);
+ var parent = element.parentNode;
+ if (parent) parent.removeChild(element);
}
-}
-function jqLiteReady(fn) {
- function trigger() {
- window.document.removeEventListener('DOMContentLoaded', trigger);
- window.removeEventListener('load', trigger);
- fn();
+ function jqLiteDocumentLoaded(action, win) {
+ win = win || window;
+ if (win.document.readyState === 'complete') {
+ // Force the action to be run async for consistent behavior
+ // 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);
+ }
}
- // check if document is already loaded
- if (window.document.readyState === 'complete') {
- window.setTimeout(fn);
- } else {
- // We can not use jqLite since we are not done loading and jQuery could be loaded later.
+ function jqLiteReady(fn) {
+ function trigger() {
+ window.document.removeEventListener('DOMContentLoaded', trigger);
+ window.removeEventListener('load', trigger);
+ fn();
+ }
+
+ // check if document is already loaded
+ if (window.document.readyState === 'complete') {
+ window.setTimeout(fn);
+ } else {
+ // We can not use jqLite since we are not done loading and jQuery could be loaded later.
- // Works for modern browsers and IE9
- window.document.addEventListener('DOMContentLoaded', trigger);
+ // Works for modern browsers and IE9
+ window.document.addEventListener('DOMContentLoaded', trigger);
- // Fallback to window.onload for others
- window.addEventListener('load', trigger);
+ // Fallback to window.onload for others
+ window.addEventListener('load', trigger);
+ }
}
-}
-//////////////////////////////////////////
-// Functions which are declared directly.
-//////////////////////////////////////////
-var JQLitePrototype = JQLite.prototype = {
- ready: jqLiteReady,
- toString: function() {
- var value = [];
- forEach(this, function(e) { value.push('' + e);});
- return '[' + value.join(', ') + ']';
- },
+ //////////////////////////////////////////
+ // Functions which are declared directly.
+ //////////////////////////////////////////
+ var JQLitePrototype = JQLite.prototype = {
+ ready: jqLiteReady,
+ toString: function toString() {
+ 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]);
- },
+ eq: function eq(index) {
+ return index >= 0 ? jqLite(this[index]) : jqLite(this[this.length + index]);
+ },
- length: 0,
- push: push,
- sort: [].sort,
- splice: [].splice
-};
+ 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',
- 'ngStep': 'step'
-};
+ //////////////////////////////////////////
+ // 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',
+ 'ngStep': 'step'
+ };
-function getBooleanAttrName(element, name) {
- // check dom last since we will most likely fail on name
- var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
+ 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;
-}
+ // booleanAttr is here twice to minimize DOM access
+ return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr;
+ }
-function getAliasedAttrName(name) {
- return ALIASED_ATTR[name];
-}
+ function getAliasedAttrName(name) {
+ return ALIASED_ATTR[name];
+ }
-forEach({
- data: jqLiteData,
- removeData: jqLiteRemoveData,
- hasData: jqLiteHasData,
- cleanData: function jqLiteCleanData(nodes) {
- for (var i = 0, ii = nodes.length; i < ii; i++) {
- jqLiteRemoveData(nodes[i]);
+ forEach({
+ data: jqLiteData,
+ removeData: jqLiteRemoveData,
+ hasData: jqLiteHasData,
+ cleanData: function jqLiteCleanData(nodes) {
+ for (var i = 0, ii = nodes.length; i < ii; i++) {
+ jqLiteRemoveData(nodes[i]);
+ }
}
- }
-}, function(fn, name) {
- JQLite[name] = fn;
-});
+ }, function (fn, name) {
+ JQLite[name] = fn;
+ });
-forEach({
- data: jqLiteData,
- inheritedData: jqLiteInheritedData,
+ 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']);
- },
+ scope: function scope(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');
- },
+ isolateScope: function isolateScope(element) {
+ // Can't use jqLiteData here directly so we stay compatible with jQuery!
+ return jqLite.data(element, '$isolateScope') || jqLite.data(element, '$isolateScopeNoTemplate');
+ },
- controller: jqLiteController,
+ controller: jqLiteController,
- injector: function(element) {
- return jqLiteInheritedData(element, '$injector');
- },
+ injector: function injector(element) {
+ return jqLiteInheritedData(element, '$injector');
+ },
- removeAttr: function(element, name) {
- element.removeAttribute(name);
- },
+ removeAttr: function removeAttr(element, name) {
+ element.removeAttribute(name);
+ },
- hasClass: jqLiteHasClass,
+ hasClass: jqLiteHasClass,
- css: function(element, name, value) {
- name = cssKebabToCamel(name);
+ css: function css(element, name, value) {
+ name = cssKebabToCamel(name);
- if (isDefined(value)) {
- element.style[name] = value;
- } else {
- return element.style[name];
- }
- },
+ if (isDefined(value)) {
+ element.style[name] = value;
+ } else {
+ return element.style[name];
+ }
+ },
- attr: function(element, name, value) {
- var ret;
- var nodeType = element.nodeType;
- if (nodeType === NODE_TYPE_TEXT || nodeType === NODE_TYPE_ATTRIBUTE || nodeType === NODE_TYPE_COMMENT ||
- !element.getAttribute) {
- return;
- }
+ attr: function attr(element, name, value) {
+ var ret;
+ var nodeType = element.nodeType;
+ if (nodeType === NODE_TYPE_TEXT || nodeType === NODE_TYPE_ATTRIBUTE || nodeType === NODE_TYPE_COMMENT || !element.getAttribute) {
+ return;
+ }
- var lowercasedName = lowercase(name);
- var isBooleanAttr = BOOLEAN_ATTR[lowercasedName];
+ var lowercasedName = lowercase(name);
+ var isBooleanAttr = BOOLEAN_ATTR[lowercasedName];
- if (isDefined(value)) {
- // setter
+ if (isDefined(value)) {
+ // setter
- if (value === null || (value === false && isBooleanAttr)) {
- element.removeAttribute(name);
+ if (value === null || value === false && isBooleanAttr) {
+ element.removeAttribute(name);
+ } else {
+ element.setAttribute(name, isBooleanAttr ? lowercasedName : value);
+ }
} else {
- element.setAttribute(name, isBooleanAttr ? lowercasedName : value);
- }
- } else {
- // getter
+ // getter
- ret = element.getAttribute(name);
+ ret = element.getAttribute(name);
- if (isBooleanAttr && ret !== null) {
- ret = lowercasedName;
+ if (isBooleanAttr && ret !== null) {
+ ret = lowercasedName;
+ }
+ // Normalize non-existing attributes to undefined (as jQuery).
+ return ret === null ? undefined : ret;
}
- // 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];
- }
- },
+ prop: function prop(element, name, value) {
+ if (isDefined(value)) {
+ element[name] = value;
+ } else {
+ return element[name];
+ }
+ },
- text: (function() {
- getText.$dv = '';
- return getText;
+ 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 : '';
+ 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;
}
- 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;
+ val: function val(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;
+ }
+ return element.value;
}
- return element.value;
- }
- element.value = value;
- },
+ element.value = value;
+ },
- html: function(element, value) {
- if (isUndefined(value)) {
- return element.innerHTML;
- }
- jqLiteDealoc(element, true);
- element.innerHTML = value;
- },
+ html: function html(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]);
+ 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;
}
- // 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;
+ // we are a write, so apply to all children
+ for (i = 0; i < nodeCount; i++) {
+ fn(this[i], arg1, arg2);
}
- 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;
}
- // 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;
+ function createEventHandler(element, events) {
+ var eventHandler = function eventHandler(event, type) {
+ // jQuery specific api
+ event.isDefaultPrevented = function () {
+ return event.defaultPrevented;
+ };
- if (!eventFnsLength) return;
+ var eventFns = events[type || event.type];
+ var eventFnsLength = eventFns ? eventFns.length : 0;
- if (isUndefined(event.immediatePropagationStopped)) {
- var originalStopImmediatePropagation = event.stopImmediatePropagation;
- event.stopImmediatePropagation = function() {
- event.immediatePropagationStopped = true;
+ if (!eventFnsLength) return;
- if (event.stopPropagation) {
- event.stopPropagation();
- }
+ if (isUndefined(event.immediatePropagationStopped)) {
+ var originalStopImmediatePropagation = event.stopImmediatePropagation;
+ event.stopImmediatePropagation = function () {
+ event.immediatePropagationStopped = true;
- if (originalStopImmediatePropagation) {
- originalStopImmediatePropagation.call(event);
- }
- };
- }
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ }
- event.isImmediatePropagationStopped = function() {
- return event.immediatePropagationStopped === true;
- };
+ if (originalStopImmediatePropagation) {
+ originalStopImmediatePropagation.call(event);
+ }
+ };
+ }
- // Some events have special handlers that wrap the real handler
- var handlerWrapper = eventFns.specialHandlerWrapper || defaultHandlerWrapper;
+ 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);
- }
+ // Some events have special handlers that wrap the real handler
+ var handlerWrapper = eventFns.specialHandlerWrapper || defaultHandlerWrapper;
- for (var i = 0; i < eventFnsLength; i++) {
- if (!event.isImmediatePropagationStopped()) {
- handlerWrapper(element, event, eventFns[i]);
+ // Copy event handlers in case event handlers array is modified during execution.
+ if (eventFnsLength > 1) {
+ eventFns = shallowCopy(eventFns);
}
- }
- };
- // TODO: this is a hack for angularMocks/clearDataCache that makes it possible to deregister all
- // events on `element`
- eventHandler.elem = element;
- return eventHandler;
-}
-
-function defaultHandlerWrapper(element, event, handler) {
- handler.call(element, event);
-}
+ for (var i = 0; i < eventFnsLength; i++) {
+ if (!event.isImmediatePropagationStopped()) {
+ handlerWrapper(element, event, eventFns[i]);
+ }
+ }
+ };
-function specialMouseHandlerWrapper(target, event, handler) {
- // Refer to jQuery's implementation of mouseenter & mouseleave
- // Read about mouseenter and mouseleave:
- // http://www.quirksmode.org/js/events_mouse.html#link8
- var 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 && !jqLiteContains.call(target, related))) {
- handler.call(target, 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;
+ function defaultHandlerWrapper(element, event, handler) {
+ handler.call(element, event);
+ }
- if (!handle) {
- handle = expandoStore.handle = createEventHandler(element, events);
+ function specialMouseHandlerWrapper(target, event, handler) {
+ // Refer to jQuery's implementation of mouseenter & mouseleave
+ // Read about mouseenter and mouseleave:
+ // http://www.quirksmode.org/js/events_mouse.html#link8
+ var 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 && !jqLiteContains.call(target, related)) {
+ handler.call(target, event);
}
+ }
- // http://jsperf.com/string-indexof-vs-split
- var types = type.indexOf(' ') >= 0 ? type.split(' ') : [type];
- var i = types.length;
+ //////////////////////////////////////////
+ // Functions iterating traversal.
+ // These functions chain results into a single
+ // selector.
+ //////////////////////////////////////////
+ forEach({
+ removeData: jqLiteRemoveData,
- var addHandler = function(type, specialHandlerWrapper, noEventListener) {
- var eventFns = events[type];
+ on: function jqLiteOn(element, type, fn, unsupported) {
+ if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters');
- if (!eventFns) {
- eventFns = events[type] = [];
- eventFns.specialHandlerWrapper = specialHandlerWrapper;
- if (type !== '$destroy' && !noEventListener) {
- element.addEventListener(type, handle);
- }
+ // Do not add event handlers to non-elements because they will not be cleaned up.
+ if (!jqLiteAcceptsData(element)) {
+ return;
}
- eventFns.push(fn);
- };
+ var expandoStore = jqLiteExpandoStore(element, true);
+ var events = expandoStore.events;
+ var handle = expandoStore.handle;
- while (i--) {
- type = types[i];
- if (MOUSE_EVENT_MAP[type]) {
- addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
- addHandler(type, undefined, true);
- } else {
- addHandler(type);
+ if (!handle) {
+ handle = expandoStore.handle = createEventHandler(element, events);
}
- }
- },
- off: jqLiteOff,
+ // http://jsperf.com/string-indexof-vs-split
+ var types = type.indexOf(' ') >= 0 ? type.split(' ') : [type];
+ var i = types.length;
- one: function(element, type, fn) {
- element = jqLite(element);
+ var addHandler = function addHandler(type, specialHandlerWrapper, noEventListener) {
+ var eventFns = events[type];
- //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);
- },
+ if (!eventFns) {
+ eventFns = events[type] = [];
+ eventFns.specialHandlerWrapper = specialHandlerWrapper;
+ if (type !== '$destroy' && !noEventListener) {
+ element.addEventListener(type, handle);
+ }
+ }
- 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;
- });
- },
+ eventFns.push(fn);
+ };
- children: function(element) {
- var children = [];
- forEach(element.childNodes, function(element) {
- if (element.nodeType === NODE_TYPE_ELEMENT) {
- children.push(element);
+ while (i--) {
+ type = types[i];
+ if (MOUSE_EVENT_MAP[type]) {
+ addHandler(MOUSE_EVENT_MAP[type], specialMouseHandlerWrapper);
+ addHandler(type, undefined, true);
+ } else {
+ addHandler(type);
+ }
}
- });
- 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);
+ off: jqLiteOff,
- for (var i = 0, ii = node.length; i < ii; i++) {
- var child = node[i];
- element.appendChild(child);
- }
- },
+ one: function one(element, type, fn) {
+ element = jqLite(element);
- prepend: function(element, node) {
- if (element.nodeType === NODE_TYPE_ELEMENT) {
- var index = element.firstChild;
- forEach(new JQLite(node), function(child) {
- element.insertBefore(child, index);
+ //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);
+ },
- wrap: function(element, wrapNode) {
- jqLiteWrapNode(element, jqLite(wrapNode).eq(0).clone()[0]);
- },
+ replaceWith: function replaceWith(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;
+ });
+ },
- remove: jqLiteRemove,
+ children: function children(element) {
+ var children = [];
+ forEach(element.childNodes, function (element) {
+ if (element.nodeType === NODE_TYPE_ELEMENT) {
+ children.push(element);
+ }
+ });
+ return children;
+ },
- detach: function(element) {
- jqLiteRemove(element, true);
- },
+ contents: function contents(element) {
+ return element.contentDocument || element.childNodes || [];
+ },
- after: function(element, newElement) {
- var index = element, parent = element.parentNode;
+ append: function append(element, node) {
+ var nodeType = element.nodeType;
+ if (nodeType !== NODE_TYPE_ELEMENT && nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT) return;
- if (parent) {
- newElement = new JQLite(newElement);
+ node = new JQLite(node);
- for (var i = 0, ii = newElement.length; i < ii; i++) {
- var node = newElement[i];
- parent.insertBefore(node, index.nextSibling);
- index = node;
+ for (var i = 0, ii = node.length; i < ii; i++) {
+ var child = node[i];
+ element.appendChild(child);
}
- }
- },
-
- 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;
- },
+ prepend: function prepend(element, node) {
+ if (element.nodeType === NODE_TYPE_ELEMENT) {
+ var index = element.firstChild;
+ forEach(new JQLite(node), function (child) {
+ element.insertBefore(child, index);
+ });
+ }
+ },
- next: function(element) {
- return element.nextElementSibling;
- },
+ wrap: function wrap(element, wrapNode) {
+ jqLiteWrapNode(element, jqLite(wrapNode).eq(0).clone()[0]);
+ },
- find: function(element, selector) {
- if (element.getElementsByTagName) {
- return element.getElementsByTagName(selector);
- } else {
- return [];
- }
- },
+ remove: jqLiteRemove,
- clone: jqLiteClone,
+ detach: function detach(element) {
+ jqLiteRemove(element, true);
+ },
- triggerHandler: function(element, event, extraParameters) {
+ after: function after(element, newElement) {
+ var index = element,
+ parent = element.parentNode;
- 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 (parent) {
+ newElement = new JQLite(newElement);
- // If a custom event was provided then extend our dummy event with it
- if (event.type) {
- dummyEvent = extend(dummyEvent, event);
+ for (var i = 0, ii = newElement.length; i < ii; i++) {
+ var node = newElement[i];
+ parent.insertBefore(node, index.nextSibling);
+ index = node;
+ }
}
+ },
- // 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;
+ addClass: jqLiteAddClass,
+ removeClass: jqLiteRemoveClass,
- 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));
+ toggleClass: function toggleClass(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);
+ });
}
- }
- return isDefined(value) ? value : this;
- };
-});
+ },
-// bind legacy bind/unbind to on/off
-JQLite.prototype.bind = JQLite.prototype.on;
-JQLite.prototype.unbind = JQLite.prototype.off;
+ parent: function parent(element) {
+ var parent = element.parentNode;
+ return parent && parent.nodeType !== NODE_TYPE_DOCUMENT_FRAGMENT ? parent : null;
+ },
+ next: function next(element) {
+ return element.nextElementSibling;
+ },
-// Provider for private $$jqLite service
-/** @this */
-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);
+ find: function find(element, selector) {
+ if (element.getElementsByTagName) {
+ return element.getElementsByTagName(selector);
+ } else {
+ return [];
}
- });
- };
-}
-
-/**
- * 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;
-}
-
-// A minimal ES2015 Map implementation.
-// Should be bug/feature equivalent to the native implementations of supported browsers
-// (for the features required in Angular).
-// See https://kangax.github.io/compat-table/es6/#test-Map
-var nanKey = Object.create(null);
-function NgMapShim() {
- this._keys = [];
- this._values = [];
- this._lastKey = NaN;
- this._lastIndex = -1;
-}
-NgMapShim.prototype = {
- _idx: function(key) {
- if (key === this._lastKey) {
- return this._lastIndex;
- }
- this._lastKey = key;
- this._lastIndex = this._keys.indexOf(key);
- return this._lastIndex;
- },
- _transformKey: function(key) {
- return isNumberNaN(key) ? nanKey : key;
- },
- get: function(key) {
- key = this._transformKey(key);
- var idx = this._idx(key);
- if (idx !== -1) {
- return this._values[idx];
- }
- },
- set: function(key, value) {
- key = this._transformKey(key);
- var idx = this._idx(key);
- if (idx === -1) {
- idx = this._lastIndex = this._keys.length;
- }
- this._keys[idx] = key;
- this._values[idx] = value;
-
- // Support: IE11
- // Do not `return this` to simulate the partial IE11 implementation
- },
- delete: function(key) {
- key = this._transformKey(key);
- var idx = this._idx(key);
- if (idx === -1) {
- return false;
- }
- this._keys.splice(idx, 1);
- this._values.splice(idx, 1);
- this._lastKey = NaN;
- this._lastIndex = -1;
- return true;
- }
-};
-
-// For now, always use `NgMapShim`, even if `window.Map` is available. Some native implementations
-// are still buggy (often in subtle ways) and can cause hard-to-debug failures. When native `Map`
-// implementations get more stable, we can reconsider switching to `window.Map` (when available).
-var NgMap = NgMapShim;
-
-var $$MapProvider = [/** @this */function() {
- this.$get = [function() {
- return NgMap;
- }];
-}];
-
-/**
- * @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.} 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 = $('{{content.label}}
');
- * $(document.body).append($div);
- *
- * angular.element(document).injector().invoke(function($compile) {
- * var scope = angular.element($div).scope();
- * $compile($div)(scope);
- * });
- * ```
- */
-
+ },
-/**
- * @ngdoc module
- * @name auto
- * @installation
- * @description
- *
- * Implicit module which gets automatically added to each {@link auto.$injector $injector}.
- */
+ clone: jqLiteClone,
-var ARROW_ARG = /^([^(]+?)=>/;
-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');
+ triggerHandler: function triggerHandler(element, event, extraParameters) {
-function stringifyFn(fn) {
- return Function.prototype.toString.call(fn);
-}
+ var dummyEvent, eventFnsCopy, handlerArgs;
+ var eventName = event.type || event;
+ var expandoStore = jqLiteExpandoStore(element);
+ var events = expandoStore && expandoStore.events;
+ var eventFns = events && events[eventName];
-function extractArgs(fn) {
- var fnText = stringifyFn(fn).replace(STRIP_COMMENTS, ''),
- args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
- return args;
-}
+ if (eventFns) {
+ // Create a dummy event to pass to the handlers
+ dummyEvent = {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = true;
+ },
+ isDefaultPrevented: function isDefaultPrevented() {
+ return this.defaultPrevented === true;
+ },
+ stopImmediatePropagation: function stopImmediatePropagation() {
+ this.immediatePropagationStopped = true;
+ },
+ isImmediatePropagationStopped: function isImmediatePropagationStopped() {
+ return this.immediatePropagationStopped === true;
+ },
+ stopPropagation: noop,
+ type: eventName,
+ target: element
+ };
-function anonFn(fn) {
- // For anonymous functions, showing at the very least the function signature can help in
- // debugging.
- var args = extractArgs(fn);
- if (args) {
- return 'function(' + (args[1] || '').replace(/[\s\r\n]+/, ' ') + ')';
- }
- return 'fn';
-}
+ // If a custom event was provided then extend our dummy event with it
+ if (event.type) {
+ dummyEvent = extend(dummyEvent, event);
+ }
-function annotate(fn, strictDi, name) {
- var $inject,
- argDecl,
- last;
+ // Copy event handlers in case event handlers array is modified during execution.
+ eventFnsCopy = shallowCopy(eventFns);
+ handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent];
- if (typeof fn === 'function') {
- if (!($inject = fn.$inject)) {
- $inject = [];
- if (fn.length) {
- if (strictDi) {
- if (!isString(name) || !name) {
- name = fn.name || anonFn(fn);
+ forEach(eventFnsCopy, function (fn) {
+ if (!dummyEvent.isImmediatePropagationStopped()) {
+ fn.apply(element, handlerArgs);
}
- throw $injectorMinErr('strictdi',
- '{0} is not using explicit annotation and cannot be invoked in strict mode', name);
- }
- argDecl = extractArgs(fn);
- 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 property
- * @name $injector#modules
- * @type {Object}
- * @description
- * A hash containing all the modules that have been loaded into the
- * $injector.
- *
- * You can use this property to find out information about a module via the
- * {@link angular.Module#info `myModule.info(...)`} method.
- *
- * For example:
- *
- * ```
- * var info = $injector.modules['ngAnimate'].info();
- * ```
- *
- * **Do not use this property to attempt to modify the modules after the application
- * has been bootstrapped.**
- */
-
-
-/**
- * @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.} 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.} 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.} 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(name, provider)} - registers a **service provider** with the
- * {@link auto.$injector $injector}
- * * {@link auto.$provide#constant constant(name, obj)} - registers a value/object that can be accessed by
- * providers and services.
- * * {@link auto.$provide#value value(name, obj)} - registers a value/object that can only be accessed by
- * services, not providers.
- * * {@link auto.$provide#factory factory(name, fn)} - registers a service **factory function**
- * that will be wrapped in a **service provider** object, whose `$get` property will contain the
- * given factory function.
- * * {@link auto.$provide#service service(name, Fn)} - registers a **constructor function**
- * that will be wrapped in a **service provider** object, whose `$get` property will instantiate
- * a new object using the given constructor function.
- * * {@link auto.$provide#decorator decorator(name, decorFn)} - registers a **decorator function** that
- * will be able to modify or replace the implementation of another service.
- *
- * 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.} $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 a factory
- * function that returns an instance instantiated by the injector from the service constructor
- * function.
- *
- * Internally it looks a bit like this:
- *
- * ```
- * {
- * $get: function() {
- * return $injector.instantiate(constructor);
- * }
- * }
- * ```
- *
- *
- * 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.} 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**. That also means it is not possible to inject other services into a 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** with the {@link auto.$injector $injector}, such as a string,
- * a number, an array, an object or a function. Like the {@link auto.$provide#value value}, it is not
- * possible to inject other services into a constant.
- *
- * But unlike {@link auto.$provide#value value}, a constant 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 **decorator function** with the {@link auto.$injector $injector}. A decorator function
- * intercepts the creation of a service, allowing it to override or modify the behavior of the
- * service. The return value of the decorator function may be the original service, or a new service
- * that replaces (or wraps and delegates to) the original service.
- *
- * You can find out more about using decorators in the {@link guide/decorators} guide.
- *
- * @param {string} name The name of the service to decorate.
- * @param {Function|Array.} decorator This function will be invoked when the service needs to be
- * provided 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 replaced, 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 (fn, name) {
+ /**
+ * chaining functions
+ */
+ JQLite.prototype[name] = function (arg1, arg2, arg3) {
+ var value;
-function createInjector(modulesToLoad, strictDi) {
- strictDi = (strictDi === true);
- var INSTANTIATING = {},
- providerSuffix = 'Provider',
- path = [],
- loadedModules = new NgMap(),
- providerCache = {
- $provide: {
- provider: supportObject(provider),
- factory: supportObject(factory),
- service: supportObject(service),
- value: supportObject(value),
- constant: supportObject(constant),
- decorator: decorator
+ 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);
}
- },
- providerInjector = (providerCache.$injector =
- createInternalInjector(providerCache, function(serviceName, caller) {
- if (angular.isString(caller)) {
- path.push(caller);
- }
- throw $injectorMinErr('unpr', 'Unknown provider: {0}', path.join(' <- '));
- })),
- instanceCache = {},
- protoInstanceInjector =
- createInternalInjector(instanceCache, function(serviceName, caller) {
- var provider = providerInjector.get(serviceName + providerSuffix, caller);
- return instanceInjector.invoke(
- provider.$get, provider, undefined, serviceName);
- }),
- instanceInjector = protoInstanceInjector;
-
- providerCache['$injector' + providerSuffix] = { $get: valueFn(protoInstanceInjector) };
- instanceInjector.modules = providerInjector.modules = createMap();
- var runBlocks = loadModules(modulesToLoad);
- instanceInjector = protoInstanceInjector.get('$injector');
- instanceInjector.strictDi = strictDi;
- forEach(runBlocks, 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);
+ } else {
+ jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
+ }
}
+ return isDefined(value) ? value : this;
};
- }
-
- 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 /** @this */ 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;
+ // bind legacy bind/unbind to on/off
+ JQLite.prototype.bind = JQLite.prototype.on;
+ JQLite.prototype.unbind = JQLite.prototype.off;
+
+ // Provider for private $$jqLite service
+ /** @this */
+ function $$jqLiteProvider() {
+ this.$get = function $$jqLite() {
+ return extend(JQLite, {
+ hasClass: function hasClass(node, classes) {
+ if (node.attr) node = node[0];
+ return jqLiteHasClass(node, classes);
+ },
+ addClass: function addClass(node, classes) {
+ if (node.attr) node = node[0];
+ return jqLiteAddClass(node, classes);
+ },
+ removeClass: function removeClass(node, classes) {
+ if (node.attr) node = node[0];
+ return jqLiteRemoveClass(node, classes);
+ }
+ });
};
}
- function factory(name, factoryFn, enforce) {
- return provider(name, {
- $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn
- });
- }
+ /**
+ * 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;
- function service(name, constructor) {
- return factory(name, ['$injector', function($injector) {
- return $injector.instantiate(constructor);
- }]);
- }
+ if (key) {
+ if (typeof key === 'function') {
+ key = obj.$$hashKey();
+ }
+ return key;
+ }
- function value(name, val) { return factory(name, valueFn(val), false); }
+ var objType = typeof obj === 'undefined' ? 'undefined' : _typeof(obj);
+ if (objType === 'function' || objType === 'object' && obj !== null) {
+ key = obj.$$hashKey = objType + ':' + (nextUidFn || nextUid)();
+ } else {
+ key = objType + ':' + obj;
+ }
- function constant(name, value) {
- assertNotHasOwnProperty(name, 'constant');
- providerCache[name] = value;
- instanceCache[name] = value;
+ return key;
}
- 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});
- };
+ // A minimal ES2015 Map implementation.
+ // Should be bug/feature equivalent to the native implementations of supported browsers
+ // (for the features required in Angular).
+ // See https://kangax.github.io/compat-table/es6/#test-Map
+ var nanKey = Object.create(null);
+ function NgMapShim() {
+ this._keys = [];
+ this._values = [];
+ this._lastKey = NaN;
+ this._lastIndex = -1;
}
-
- ////////////////////////////////////
- // 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.set(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]);
- }
+ NgMapShim.prototype = {
+ _idx: function _idx(key) {
+ if (key === this._lastKey) {
+ return this._lastIndex;
}
-
- try {
- if (isString(module)) {
- moduleFn = angularModule(module);
- instanceInjector.modules[module] = moduleFn;
- 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.
- // eslint-disable-next-line no-ex-assign
- e = e.message + '\n' + e.stack;
- }
- throw $injectorMinErr('modulerr', 'Failed to instantiate module {0} due to:\n{1}',
- module, e.stack || e.message || e);
+ this._lastKey = key;
+ this._lastIndex = this._keys.indexOf(key);
+ return this._lastIndex;
+ },
+ _transformKey: function _transformKey(key) {
+ return isNumberNaN(key) ? nanKey : key;
+ },
+ get: function get(key) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ if (idx !== -1) {
+ return this._values[idx];
}
- });
- return runBlocks;
- }
-
- ////////////////////////////////////
- // internal Injector
- ////////////////////////////////////
-
- function createInternalInjector(cache, factory) {
+ },
+ set: function set(key, value) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ if (idx === -1) {
+ idx = this._lastIndex = this._keys.length;
+ }
+ this._keys[idx] = key;
+ this._values[idx] = value;
- 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;
- cache[serviceName] = factory(serviceName, caller);
- return cache[serviceName];
- } catch (err) {
- if (cache[serviceName] === INSTANTIATING) {
- delete cache[serviceName];
- }
- throw err;
- } finally {
- path.shift();
- }
+ // Support: IE11
+ // Do not `return this` to simulate the partial IE11 implementation
+ },
+ delete: function _delete(key) {
+ key = this._transformKey(key);
+ var idx = this._idx(key);
+ if (idx === -1) {
+ return false;
}
+ this._keys.splice(idx, 1);
+ this._values.splice(idx, 1);
+ this._lastKey = NaN;
+ this._lastIndex = -1;
+ return true;
}
+ };
+ // For now, always use `NgMapShim`, even if `window.Map` is available. Some native implementations
+ // are still buggy (often in subtle ways) and can cause hard-to-debug failures. When native `Map`
+ // implementations get more stable, we can reconsider switching to `window.Map` (when available).
+ var NgMap = NgMapShim;
- function injectionArgs(fn, locals, serviceName) {
- var args = [],
- $inject = createInjector.$$annotate(fn, strictDi, serviceName);
-
- for (var i = 0, length = $inject.length; i < length; i++) {
- var 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));
- }
- return args;
- }
+ var $$MapProvider = [/** @this */function () {
+ this.$get = [function () {
+ return NgMap;
+ }];
+ }];
- function isClass(func) {
- // Support: IE 9-11 only
- // IE 9-11 do not support classes and IE9 leaks with the code below.
- if (msie || typeof func !== 'function') {
- return false;
- }
- var result = func.$$ngIsClass;
- if (!isBoolean(result)) {
- // Support: Edge 12-13 only
- // See: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/6156135/
- result = func.$$ngIsClass = /^(?:class\b|constructor\()/.test(stringifyFn(func));
- }
- return result;
- }
+ /**
+ * @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.