Created
July 31, 2014 22:00
-
-
Save Rhionin/cbe8b93de91e6bec261b to your computer and use it in GitHub Desktop.
angular-translate-2.2.0
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /*! | |
| * angular-translate - v2.2.0 - 2014-06-03 | |
| * http://github.com/PascalPrecht/angular-translate | |
| * Copyright (c) 2014 ; Licensed MIT | |
| */ | |
| angular.module('pascalprecht.translate', ['ng']).run([ | |
| '$translate', | |
| function ($translate) { | |
| var key = $translate.storageKey(), storage = $translate.storage(); | |
| if (storage) { | |
| if (!storage.get(key)) { | |
| if (angular.isString($translate.preferredLanguage())) { | |
| $translate.use($translate.preferredLanguage()); | |
| } else { | |
| storage.set(key, $translate.use()); | |
| } | |
| } else { | |
| $translate.use(storage.get(key)); | |
| } | |
| } else if (angular.isString($translate.preferredLanguage())) { | |
| $translate.use($translate.preferredLanguage()); | |
| } | |
| } | |
| ]); | |
| angular.module('pascalprecht.translate').provider('$translate', [ | |
| '$STORAGE_KEY', | |
| function ($STORAGE_KEY) { | |
| var $translationTable = {}, $preferredLanguage, $availableLanguageKeys = [], $languageKeyAliases, $fallbackLanguage, $fallbackWasString, $uses, $nextLang, $storageFactory, $storageKey = $STORAGE_KEY, $storagePrefix, $missingTranslationHandlerFactory, $interpolationFactory, $interpolatorFactories = [], $interpolationSanitizationStrategy = false, $loaderFactory, $cloakClassName = 'translate-cloak', $loaderOptions, $notFoundIndicatorLeft, $notFoundIndicatorRight, $postCompilingEnabled = false, NESTED_OBJECT_DELIMITER = '.'; | |
| var getLocale = function () { | |
| var nav = window.navigator; | |
| return (nav.language || nav.browserLanguage || nav.systemLanguage || nav.userLanguage || '').split('-').join('_'); | |
| }; | |
| var negotiateLocale = function (preferred) { | |
| var avail = [], locale = angular.lowercase(preferred), i = 0, n = $availableLanguageKeys.length; | |
| for (; i < n; i++) { | |
| avail.push(angular.lowercase($availableLanguageKeys[i])); | |
| } | |
| if (avail.indexOf(locale) > -1) { | |
| return preferred; | |
| } | |
| if ($languageKeyAliases) { | |
| var alias; | |
| for (var langKeyAlias in $languageKeyAliases) { | |
| var hasWildcardKey = false; | |
| var hasExactKey = $languageKeyAliases.hasOwnProperty(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 (avail.indexOf(angular.lowercase(alias)) > -1) { | |
| return alias; | |
| } | |
| } | |
| } | |
| } | |
| var parts = preferred.split('_'); | |
| if (parts.length > 1 && avail.indexOf(angular.lowercase(parts[0])) > -1) { | |
| return parts[0]; | |
| } | |
| return preferred; | |
| }; | |
| var translations = function (langKey, translationTable) { | |
| if (!langKey && !translationTable) { | |
| return $translationTable; | |
| } | |
| if (langKey && !translationTable) { | |
| if (angular.isString(langKey)) { | |
| return $translationTable[langKey]; | |
| } | |
| } else { | |
| if (!angular.isObject($translationTable[langKey])) { | |
| $translationTable[langKey] = {}; | |
| } | |
| angular.extend($translationTable[langKey], flatObject(translationTable)); | |
| } | |
| return this; | |
| }; | |
| this.translations = translations; | |
| this.cloakClassName = function (name) { | |
| if (!name) { | |
| return $cloakClassName; | |
| } | |
| $cloakClassName = name; | |
| return this; | |
| }; | |
| var flatObject = function (data, path, result, prevKey) { | |
| var key, keyWithPath, keyWithShortPath, val; | |
| if (!path) { | |
| path = []; | |
| } | |
| if (!result) { | |
| result = {}; | |
| } | |
| for (key in data) { | |
| if (!data.hasOwnProperty(key)) { | |
| continue; | |
| } | |
| val = data[key]; | |
| if (angular.isObject(val)) { | |
| flatObject(val, path.concat(key), result, key); | |
| } else { | |
| keyWithPath = path.length ? '' + path.join(NESTED_OBJECT_DELIMITER) + NESTED_OBJECT_DELIMITER + key : key; | |
| if (path.length && key === prevKey) { | |
| keyWithShortPath = '' + path.join(NESTED_OBJECT_DELIMITER); | |
| result[keyWithShortPath] = '@:' + keyWithPath; | |
| } | |
| result[keyWithPath] = val; | |
| } | |
| } | |
| return result; | |
| }; | |
| this.addInterpolation = function (factory) { | |
| $interpolatorFactories.push(factory); | |
| return this; | |
| }; | |
| this.useMessageFormatInterpolation = function () { | |
| return this.useInterpolation('$translateMessageFormatInterpolation'); | |
| }; | |
| this.useInterpolation = function (factory) { | |
| $interpolationFactory = factory; | |
| return this; | |
| }; | |
| this.useSanitizeValueStrategy = function (value) { | |
| $interpolationSanitizationStrategy = value; | |
| return this; | |
| }; | |
| this.preferredLanguage = function (langKey) { | |
| if (langKey) { | |
| $preferredLanguage = langKey; | |
| return this; | |
| } | |
| return $preferredLanguage; | |
| }; | |
| this.translationNotFoundIndicator = function (indicator) { | |
| this.translationNotFoundIndicatorLeft(indicator); | |
| this.translationNotFoundIndicatorRight(indicator); | |
| return this; | |
| }; | |
| this.translationNotFoundIndicatorLeft = function (indicator) { | |
| if (!indicator) { | |
| return $notFoundIndicatorLeft; | |
| } | |
| $notFoundIndicatorLeft = indicator; | |
| return this; | |
| }; | |
| this.translationNotFoundIndicatorRight = function (indicator) { | |
| if (!indicator) { | |
| return $notFoundIndicatorRight; | |
| } | |
| $notFoundIndicatorRight = indicator; | |
| return this; | |
| }; | |
| 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)) { | |
| $fallbackLanguage.push($preferredLanguage); | |
| } | |
| return this; | |
| } else { | |
| if ($fallbackWasString) { | |
| return $fallbackLanguage[0]; | |
| } else { | |
| return $fallbackLanguage; | |
| } | |
| } | |
| }; | |
| this.use = function (langKey) { | |
| if (langKey) { | |
| if (!$translationTable[langKey] && !$loaderFactory) { | |
| throw new Error('$translateProvider couldn\'t find translationTable for langKey: \'' + langKey + '\''); | |
| } | |
| $uses = langKey; | |
| return this; | |
| } | |
| return $uses; | |
| }; | |
| var storageKey = function (key) { | |
| if (!key) { | |
| if ($storagePrefix) { | |
| return $storagePrefix + $storageKey; | |
| } | |
| return $storageKey; | |
| } | |
| $storageKey = key; | |
| }; | |
| this.storageKey = storageKey; | |
| this.useUrlLoader = function (url) { | |
| return this.useLoader('$translateUrlLoader', { url: url }); | |
| }; | |
| this.useStaticFilesLoader = function (options) { | |
| return this.useLoader('$translateStaticFilesLoader', options); | |
| }; | |
| this.useLoader = function (loaderFactory, options) { | |
| $loaderFactory = loaderFactory; | |
| $loaderOptions = options || {}; | |
| return this; | |
| }; | |
| this.useLocalStorage = function () { | |
| return this.useStorage('$translateLocalStorage'); | |
| }; | |
| this.useCookieStorage = function () { | |
| return this.useStorage('$translateCookieStorage'); | |
| }; | |
| this.useStorage = function (storageFactory) { | |
| $storageFactory = storageFactory; | |
| return this; | |
| }; | |
| this.storagePrefix = function (prefix) { | |
| if (!prefix) { | |
| return prefix; | |
| } | |
| $storagePrefix = prefix; | |
| return this; | |
| }; | |
| this.useMissingTranslationHandlerLog = function () { | |
| return this.useMissingTranslationHandler('$translateMissingTranslationHandlerLog'); | |
| }; | |
| this.useMissingTranslationHandler = function (factory) { | |
| $missingTranslationHandlerFactory = factory; | |
| return this; | |
| }; | |
| this.usePostCompiling = function (value) { | |
| $postCompilingEnabled = !!value; | |
| return this; | |
| }; | |
| this.determinePreferredLanguage = function (fn) { | |
| var locale = fn && angular.isFunction(fn) ? fn() : getLocale(); | |
| if (!$availableLanguageKeys.length) { | |
| $preferredLanguage = locale; | |
| } else { | |
| $preferredLanguage = negotiateLocale(locale); | |
| } | |
| return this; | |
| }; | |
| this.registerAvailableLanguageKeys = function (languageKeys, aliases) { | |
| if (languageKeys) { | |
| $availableLanguageKeys = languageKeys; | |
| if (aliases) { | |
| $languageKeyAliases = aliases; | |
| } | |
| return this; | |
| } | |
| return $availableLanguageKeys; | |
| }; | |
| 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) { | |
| if (angular.isArray(translationId)) { | |
| var translateAll = function (translationIds) { | |
| var results = {}; | |
| var promises = []; | |
| var translate = function (translationId) { | |
| var deferred = $q.defer(); | |
| var regardless = function (value) { | |
| results[translationId] = value; | |
| deferred.resolve([ | |
| translationId, | |
| value | |
| ]); | |
| }; | |
| $translate(translationId, interpolateParams, interpolationId).then(regardless, regardless); | |
| return deferred.promise; | |
| }; | |
| for (var i = 0, c = translationIds.length; i < c; i++) { | |
| promises.push(translate(translationIds[i])); | |
| } | |
| return $q.all(promises).then(function () { | |
| return results; | |
| }); | |
| }; | |
| return translateAll(translationId); | |
| } | |
| var deferred = $q.defer(); | |
| if (translationId) { | |
| translationId = translationId.trim(); | |
| } | |
| var promiseToWaitFor = function () { | |
| var promise = $preferredLanguage ? langPromises[$preferredLanguage] : langPromises[$uses]; | |
| fallbackIndex = 0; | |
| if ($storageFactory && !promise) { | |
| var langKey = Storage.get($storageKey); | |
| promise = langPromises[langKey]; | |
| if ($fallbackLanguage && $fallbackLanguage.length) { | |
| var index = indexOf($fallbackLanguage, langKey); | |
| fallbackIndex = index > -1 ? index += 1 : 0; | |
| $fallbackLanguage.push($preferredLanguage); | |
| } | |
| } | |
| return promise; | |
| }(); | |
| if (!promiseToWaitFor) { | |
| determineTranslation(translationId, interpolateParams, interpolationId).then(deferred.resolve, deferred.reject); | |
| } else { | |
| promiseToWaitFor.then(function () { | |
| determineTranslation(translationId, interpolateParams, interpolationId).then(deferred.resolve, deferred.reject); | |
| }, deferred.reject); | |
| } | |
| return deferred.promise; | |
| }; | |
| var indexOf = function (array, searchElement) { | |
| for (var i = 0, len = array.length; i < len; i++) { | |
| if (array[i] === searchElement) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| }; | |
| var applyNotFoundIndicators = function (translationId) { | |
| if ($notFoundIndicatorLeft) { | |
| translationId = [ | |
| $notFoundIndicatorLeft, | |
| translationId | |
| ].join(' '); | |
| } | |
| if ($notFoundIndicatorRight) { | |
| translationId = [ | |
| translationId, | |
| $notFoundIndicatorRight | |
| ].join(' '); | |
| } | |
| return translationId; | |
| }; | |
| var useLanguage = function (key) { | |
| $uses = key; | |
| $rootScope.$emit('$translateChangeSuccess'); | |
| if ($storageFactory) { | |
| Storage.set($translate.storageKey(), $uses); | |
| } | |
| defaultInterpolator.setLocale($uses); | |
| angular.forEach(interpolatorHashMap, function (interpolator, id) { | |
| interpolatorHashMap[id].setLocale($uses); | |
| }); | |
| $rootScope.$emit('$translateChangeEnd'); | |
| }; | |
| var loadAsync = function (key) { | |
| if (!key) { | |
| throw 'No language key specified for loading.'; | |
| } | |
| var deferred = $q.defer(); | |
| $rootScope.$emit('$translateLoadingStart'); | |
| pendingLoader = true; | |
| $injector.get($loaderFactory)(angular.extend($loaderOptions, { key: key })).then(function (data) { | |
| var translationTable = {}; | |
| $rootScope.$emit('$translateLoadingSuccess'); | |
| 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'); | |
| }, function (key) { | |
| $rootScope.$emit('$translateLoadingError'); | |
| deferred.reject(key); | |
| $rootScope.$emit('$translateLoadingEnd'); | |
| }); | |
| return deferred.promise; | |
| }; | |
| if ($storageFactory) { | |
| Storage = $injector.get($storageFactory); | |
| if (!Storage.get || !Storage.set) { | |
| throw new Error('Couldn\'t use storage \'' + $storageFactory + '\', missing get() or set() method!'); | |
| } | |
| } | |
| if (angular.isFunction(defaultInterpolator.useSanitizeValueStrategy)) { | |
| defaultInterpolator.useSanitizeValueStrategy($interpolationSanitizationStrategy); | |
| } | |
| if ($interpolatorFactories.length) { | |
| angular.forEach($interpolatorFactories, function (interpolatorFactory) { | |
| var interpolator = $injector.get(interpolatorFactory); | |
| interpolator.setLocale($preferredLanguage || $uses); | |
| if (angular.isFunction(interpolator.useSanitizeValueStrategy)) { | |
| interpolator.useSanitizeValueStrategy($interpolationSanitizationStrategy); | |
| } | |
| interpolatorHashMap[interpolator.getInterpolationIdentifier()] = interpolator; | |
| }); | |
| } | |
| var getTranslationTable = function (langKey) { | |
| var deferred = $q.defer(); | |
| if ($translationTable.hasOwnProperty(langKey)) { | |
| deferred.resolve($translationTable[langKey]); | |
| return deferred.promise; | |
| } else { | |
| langPromises[langKey].then(function (data) { | |
| translations(data.key, data.table); | |
| deferred.resolve(data.table); | |
| }, deferred.reject); | |
| } | |
| return deferred.promise; | |
| }; | |
| var getFallbackTranslation = function (langKey, translationId, interpolateParams, Interpolator) { | |
| var deferred = $q.defer(); | |
| getTranslationTable(langKey).then(function (translationTable) { | |
| if (translationTable.hasOwnProperty(translationId)) { | |
| Interpolator.setLocale(langKey); | |
| deferred.resolve(Interpolator.interpolate(translationTable[translationId], interpolateParams)); | |
| Interpolator.setLocale($uses); | |
| } else { | |
| deferred.reject(); | |
| } | |
| }, deferred.reject); | |
| return deferred.promise; | |
| }; | |
| var getFallbackTranslationInstant = function (langKey, translationId, interpolateParams, Interpolator) { | |
| var result, translationTable = $translationTable[langKey]; | |
| if (translationTable.hasOwnProperty(translationId)) { | |
| Interpolator.setLocale(langKey); | |
| result = Interpolator.interpolate(translationTable[translationId], interpolateParams); | |
| Interpolator.setLocale($uses); | |
| } | |
| return result; | |
| }; | |
| var resolveForFallbackLanguage = function (fallbackLanguageIndex, translationId, interpolateParams, Interpolator) { | |
| var deferred = $q.defer(); | |
| if (fallbackLanguageIndex < $fallbackLanguage.length) { | |
| var langKey = $fallbackLanguage[fallbackLanguageIndex]; | |
| getFallbackTranslation(langKey, translationId, interpolateParams, Interpolator).then(function (translation) { | |
| deferred.resolve(translation); | |
| }, function () { | |
| var nextFallbackLanguagePromise = resolveForFallbackLanguage(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator); | |
| deferred.resolve(nextFallbackLanguagePromise); | |
| }); | |
| } else { | |
| if ($missingTranslationHandlerFactory) { | |
| var resultString = $injector.get($missingTranslationHandlerFactory)(translationId, $uses); | |
| if (resultString !== undefined) { | |
| deferred.resolve(resultString); | |
| } else { | |
| deferred.resolve(translationId); | |
| } | |
| } else { | |
| deferred.resolve(translationId); | |
| } | |
| } | |
| return deferred.promise; | |
| }; | |
| var resolveForFallbackLanguageInstant = function (fallbackLanguageIndex, translationId, interpolateParams, Interpolator) { | |
| var result; | |
| if (fallbackLanguageIndex < $fallbackLanguage.length) { | |
| var langKey = $fallbackLanguage[fallbackLanguageIndex]; | |
| result = getFallbackTranslationInstant(langKey, translationId, interpolateParams, Interpolator); | |
| if (!result) { | |
| result = resolveForFallbackLanguageInstant(fallbackLanguageIndex + 1, translationId, interpolateParams, Interpolator); | |
| } | |
| } | |
| return result; | |
| }; | |
| var fallbackTranslation = function (translationId, interpolateParams, Interpolator) { | |
| return resolveForFallbackLanguage(startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex, translationId, interpolateParams, Interpolator); | |
| }; | |
| var fallbackTranslationInstant = function (translationId, interpolateParams, Interpolator) { | |
| return resolveForFallbackLanguageInstant(startFallbackIteration > 0 ? startFallbackIteration : fallbackIndex, translationId, interpolateParams, Interpolator); | |
| }; | |
| var determineTranslation = function (translationId, interpolateParams, interpolationId) { | |
| var deferred = $q.defer(); | |
| var table = $uses ? $translationTable[$uses] : $translationTable, Interpolator = interpolationId ? interpolatorHashMap[interpolationId] : defaultInterpolator; | |
| if (table && table.hasOwnProperty(translationId)) { | |
| var translation = table[translationId]; | |
| if (translation.substr(0, 2) === '@:') { | |
| $translate(translation.substr(2), interpolateParams, interpolationId).then(deferred.resolve, deferred.reject); | |
| } else { | |
| deferred.resolve(Interpolator.interpolate(translation, interpolateParams)); | |
| } | |
| } else { | |
| if ($missingTranslationHandlerFactory && !pendingLoader) { | |
| $injector.get($missingTranslationHandlerFactory)(translationId, $uses); | |
| } | |
| if ($uses && $fallbackLanguage && $fallbackLanguage.length) { | |
| fallbackTranslation(translationId, interpolateParams, Interpolator).then(function (translation) { | |
| deferred.resolve(translation); | |
| }, function (_translationId) { | |
| deferred.reject(applyNotFoundIndicators(_translationId)); | |
| }); | |
| } else { | |
| deferred.reject(applyNotFoundIndicators(translationId)); | |
| } | |
| } | |
| return deferred.promise; | |
| }; | |
| var determineTranslationInstant = function (translationId, interpolateParams, interpolationId) { | |
| var result, table = $uses ? $translationTable[$uses] : $translationTable, Interpolator = interpolationId ? interpolatorHashMap[interpolationId] : defaultInterpolator; | |
| if (table && table.hasOwnProperty(translationId)) { | |
| var translation = table[translationId]; | |
| if (translation.substr(0, 2) === '@:') { | |
| result = determineTranslationInstant(translation.substr(2), interpolateParams, interpolationId); | |
| } else { | |
| result = Interpolator.interpolate(translation, interpolateParams); | |
| } | |
| } else { | |
| if ($missingTranslationHandlerFactory && !pendingLoader) { | |
| $injector.get($missingTranslationHandlerFactory)(translationId, $uses); | |
| } | |
| if ($uses && $fallbackLanguage && $fallbackLanguage.length) { | |
| fallbackIndex = 0; | |
| result = fallbackTranslationInstant(translationId, interpolateParams, Interpolator); | |
| } else { | |
| result = applyNotFoundIndicators(translationId); | |
| } | |
| } | |
| return result; | |
| }; | |
| $translate.preferredLanguage = function () { | |
| return $preferredLanguage; | |
| }; | |
| $translate.cloakClassName = function () { | |
| return $cloakClassName; | |
| }; | |
| $translate.fallbackLanguage = function (langKey) { | |
| if (langKey !== undefined && langKey !== null) { | |
| fallbackStack(langKey); | |
| 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; | |
| } | |
| }; | |
| $translate.useFallbackLanguage = function (langKey) { | |
| if (langKey !== undefined && langKey !== null) { | |
| if (!langKey) { | |
| startFallbackIteration = 0; | |
| } else { | |
| var langKeyPosition = indexOf($fallbackLanguage, langKey); | |
| if (langKeyPosition > -1) { | |
| startFallbackIteration = langKeyPosition; | |
| } | |
| } | |
| } | |
| }; | |
| $translate.proposedLanguage = function () { | |
| return $nextLang; | |
| }; | |
| $translate.storage = function () { | |
| return Storage; | |
| }; | |
| $translate.use = function (key) { | |
| if (!key) { | |
| return $uses; | |
| } | |
| var deferred = $q.defer(); | |
| $rootScope.$emit('$translateChangeStart'); | |
| var aliasedKey = negotiateLocale(key); | |
| if (aliasedKey) { | |
| key = aliasedKey; | |
| } | |
| if (!$translationTable[key] && $loaderFactory) { | |
| $nextLang = key; | |
| langPromises[key] = loadAsync(key).then(function (translation) { | |
| translations(translation.key, translation.table); | |
| deferred.resolve(translation.key); | |
| if ($nextLang === key) { | |
| useLanguage(translation.key); | |
| $nextLang = undefined; | |
| } | |
| }, function (key) { | |
| $nextLang = undefined; | |
| $rootScope.$emit('$translateChangeError'); | |
| deferred.reject(key); | |
| $rootScope.$emit('$translateChangeEnd'); | |
| }); | |
| } else { | |
| deferred.resolve(key); | |
| useLanguage(key); | |
| } | |
| return deferred.promise; | |
| }; | |
| $translate.storageKey = function () { | |
| return storageKey(); | |
| }; | |
| $translate.isPostCompilingEnabled = function () { | |
| return $postCompilingEnabled; | |
| }; | |
| $translate.refresh = function (langKey) { | |
| if (!$loaderFactory) { | |
| throw new Error('Couldn\'t refresh translation table, no loader registered!'); | |
| } | |
| var deferred = $q.defer(); | |
| function resolve() { | |
| deferred.resolve(); | |
| $rootScope.$emit('$translateRefreshEnd'); | |
| } | |
| function reject() { | |
| deferred.reject(); | |
| $rootScope.$emit('$translateRefreshEnd'); | |
| } | |
| $rootScope.$emit('$translateRefreshStart'); | |
| if (!langKey) { | |
| var tables = []; | |
| if ($fallbackLanguage && $fallbackLanguage.length) { | |
| for (var i = 0, len = $fallbackLanguage.length; i < len; i++) { | |
| tables.push(loadAsync($fallbackLanguage[i])); | |
| } | |
| } | |
| if ($uses) { | |
| tables.push(loadAsync($uses)); | |
| } | |
| $q.all(tables).then(function (tableData) { | |
| angular.forEach(tableData, function (data) { | |
| if ($translationTable[data.key]) { | |
| delete $translationTable[data.key]; | |
| } | |
| translations(data.key, data.table); | |
| }); | |
| if ($uses) { | |
| useLanguage($uses); | |
| } | |
| resolve(); | |
| }); | |
| } else if ($translationTable[langKey]) { | |
| loadAsync(langKey).then(function (data) { | |
| translations(data.key, data.table); | |
| if (langKey === $uses) { | |
| useLanguage($uses); | |
| } | |
| resolve(); | |
| }, reject); | |
| } else { | |
| reject(); | |
| } | |
| return deferred.promise; | |
| }; | |
| $translate.instant = function (translationId, interpolateParams, interpolationId) { | |
| if (translationId === null || angular.isUndefined(translationId)) { | |
| return translationId; | |
| } | |
| 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); | |
| } | |
| return results; | |
| } | |
| if (angular.isString(translationId) && translationId.length < 1) { | |
| return translationId; | |
| } | |
| if (translationId) { | |
| translationId = translationId.trim(); | |
| } | |
| 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); | |
| } | |
| } | |
| if (typeof result !== 'undefined') { | |
| break; | |
| } | |
| } | |
| if (!result && result !== '') { | |
| result = translationId; | |
| if ($missingTranslationHandlerFactory && !pendingLoader) { | |
| $injector.get($missingTranslationHandlerFactory)(translationId, $uses); | |
| } | |
| } | |
| return result; | |
| }; | |
| if ($loaderFactory) { | |
| if (angular.equals($translationTable, {})) { | |
| $translate.use($translate.use()); | |
| } | |
| if ($fallbackLanguage && $fallbackLanguage.length) { | |
| for (var i = 0, len = $fallbackLanguage.length; i < len; i++) { | |
| langPromises[$fallbackLanguage[i]] = loadAsync($fallbackLanguage[i]); | |
| } | |
| } | |
| } | |
| return $translate; | |
| } | |
| ]; | |
| } | |
| ]); | |
| angular.module('pascalprecht.translate').factory('$translateDefaultInterpolation', [ | |
| '$interpolate', | |
| function ($interpolate) { | |
| var $translateInterpolator = {}, $locale, $identifier = 'default', $sanitizeValueStrategy = null, sanitizeValueStrategies = { | |
| escaped: function (params) { | |
| var result = {}; | |
| for (var key in params) { | |
| if (params.hasOwnProperty(key)) { | |
| result[key] = angular.element('<div></div>').text(params[key]).html(); | |
| } | |
| } | |
| return result; | |
| } | |
| }; | |
| var sanitizeParams = function (params) { | |
| var result; | |
| if (angular.isFunction(sanitizeValueStrategies[$sanitizeValueStrategy])) { | |
| result = sanitizeValueStrategies[$sanitizeValueStrategy](params); | |
| } else { | |
| result = params; | |
| } | |
| return result; | |
| }; | |
| $translateInterpolator.setLocale = function (locale) { | |
| $locale = locale; | |
| }; | |
| $translateInterpolator.getInterpolationIdentifier = function () { | |
| return $identifier; | |
| }; | |
| $translateInterpolator.useSanitizeValueStrategy = function (value) { | |
| $sanitizeValueStrategy = value; | |
| return this; | |
| }; | |
| $translateInterpolator.interpolate = function (string, interpolateParams) { | |
| if ($sanitizeValueStrategy) { | |
| interpolateParams = sanitizeParams(interpolateParams); | |
| } | |
| return $interpolate(string)(interpolateParams || {}); | |
| }; | |
| return $translateInterpolator; | |
| } | |
| ]); | |
| angular.module('pascalprecht.translate').constant('$STORAGE_KEY', 'NG_TRANSLATE_LANG_KEY'); | |
| angular.module('pascalprecht.translate').directive('translate', [ | |
| '$translate', | |
| '$q', | |
| '$interpolate', | |
| '$compile', | |
| '$parse', | |
| '$rootScope', | |
| function ($translate, $q, $interpolate, $compile, $parse, $rootScope) { | |
| return { | |
| restrict: 'AE', | |
| scope: true, | |
| compile: function (tElement, tAttr) { | |
| var translateValuesExist = tAttr.translateValues ? tAttr.translateValues : undefined; | |
| var translateInterpolation = tAttr.translateInterpolation ? tAttr.translateInterpolation : undefined; | |
| var translateValueExist = tElement[0].outerHTML.match(/translate-value-+/i); | |
| return function linkFn(scope, iElement, iAttr) { | |
| scope.interpolateParams = {}; | |
| iAttr.$observe('translate', function (translationId) { | |
| if (angular.equals(translationId, '') || !angular.isDefined(translationId)) { | |
| scope.translationId = $interpolate(iElement.text().replace(/^\s+|\s+$/g, ''))(scope.$parent); | |
| } else { | |
| scope.translationId = translationId; | |
| } | |
| }); | |
| iAttr.$observe('translateDefault', function (value) { | |
| scope.defaultText = value; | |
| }); | |
| if (translateValuesExist) { | |
| iAttr.$observe('translateValues', function (interpolateParams) { | |
| if (interpolateParams) { | |
| scope.$parent.$watch(function () { | |
| angular.extend(scope.interpolateParams, $parse(interpolateParams)(scope.$parent)); | |
| }); | |
| } | |
| }); | |
| } | |
| if (translateValueExist) { | |
| var fn = function (attrName) { | |
| iAttr.$observe(attrName, function (value) { | |
| scope.interpolateParams[angular.lowercase(attrName.substr(14, 1)) + attrName.substr(15)] = value; | |
| }); | |
| }; | |
| for (var attr in iAttr) { | |
| if (iAttr.hasOwnProperty(attr) && attr.substr(0, 14) === 'translateValue' && attr !== 'translateValues') { | |
| fn(attr); | |
| } | |
| } | |
| } | |
| var applyElementContent = function (value, scope, successful) { | |
| if (!successful && typeof scope.defaultText !== 'undefined') { | |
| value = scope.defaultText; | |
| } | |
| iElement.html(value); | |
| var globallyEnabled = $translate.isPostCompilingEnabled(); | |
| var locallyDefined = typeof tAttr.translateCompile !== 'undefined'; | |
| var locallyEnabled = locallyDefined && tAttr.translateCompile !== 'false'; | |
| if (globallyEnabled && !locallyDefined || locallyEnabled) { | |
| $compile(iElement.contents())(scope); | |
| } | |
| }; | |
| var updateTranslationFn = function () { | |
| if (!translateValuesExist && !translateValueExist) { | |
| return function () { | |
| var unwatch = scope.$watch('translationId', function (value) { | |
| if (scope.translationId && value) { | |
| $translate(value, {}, translateInterpolation).then(function (translation) { | |
| applyElementContent(translation, scope, true); | |
| unwatch(); | |
| }, function (translationId) { | |
| applyElementContent(translationId, scope, false); | |
| unwatch(); | |
| }); | |
| } | |
| }, true); | |
| }; | |
| } else { | |
| return function () { | |
| var updateTranslations = function () { | |
| if (scope.translationId && scope.interpolateParams) { | |
| $translate(scope.translationId, scope.interpolateParams, translateInterpolation).then(function (translation) { | |
| applyElementContent(translation, scope, true); | |
| }, function (translationId) { | |
| applyElementContent(translationId, scope, false); | |
| }); | |
| } | |
| }; | |
| scope.$watch('interpolateParams', updateTranslations, true); | |
| scope.$watch('translationId', updateTranslations); | |
| }; | |
| } | |
| }(); | |
| var unbind = $rootScope.$on('$translateChangeSuccess', updateTranslationFn); | |
| updateTranslationFn(); | |
| scope.$on('$destroy', unbind); | |
| }; | |
| } | |
| }; | |
| } | |
| ]); | |
| angular.module('pascalprecht.translate').directive('translateCloak', [ | |
| '$rootScope', | |
| '$translate', | |
| function ($rootScope, $translate) { | |
| return { | |
| compile: function (tElement) { | |
| $rootScope.$on('$translateLoadingSuccess', function () { | |
| tElement.removeClass($translate.cloakClassName()); | |
| }); | |
| tElement.addClass($translate.cloakClassName()); | |
| } | |
| }; | |
| } | |
| ]); | |
| angular.module('pascalprecht.translate').filter('translate', [ | |
| '$parse', | |
| '$translate', | |
| function ($parse, $translate) { | |
| return function (translationId, interpolateParams, interpolation) { | |
| if (!angular.isObject(interpolateParams)) { | |
| interpolateParams = $parse(interpolateParams)(this); | |
| } | |
| return $translate.instant(translationId, interpolateParams, interpolation); | |
| }; | |
| } | |
| ]); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment