1 | import { Injectable, EventEmitter, Optional } from "@angular/core";
|
2 | import { Observable } from "rxjs/Observable";
|
3 | import "rxjs/add/observable/of";
|
4 | import "rxjs/add/operator/share";
|
5 | import "rxjs/add/operator/map";
|
6 | import "rxjs/add/operator/merge";
|
7 | import "rxjs/add/operator/toArray";
|
8 | import "rxjs/add/operator/take";
|
9 | import { TranslateParser } from "./translate.parser";
|
10 | import { isDefined } from "./util";
|
11 | export var MissingTranslationHandler = (function () {
|
12 | function MissingTranslationHandler() {
|
13 | }
|
14 | return MissingTranslationHandler;
|
15 | }());
|
16 | export var TranslateLoader = (function () {
|
17 | function TranslateLoader() {
|
18 | }
|
19 | return TranslateLoader;
|
20 | }());
|
21 | export var TranslateStaticLoader = (function () {
|
22 | function TranslateStaticLoader(http, prefix, suffix) {
|
23 | if (prefix === void 0) { prefix = "i18n"; }
|
24 | if (suffix === void 0) { suffix = ".json"; }
|
25 | this.http = http;
|
26 | this.prefix = prefix;
|
27 | this.suffix = suffix;
|
28 | }
|
29 | |
30 |
|
31 |
|
32 |
|
33 |
|
34 | TranslateStaticLoader.prototype.getTranslation = function (lang) {
|
35 | return this.http.get(this.prefix + "/" + lang + this.suffix)
|
36 | .map(function (res) { return res.json(); });
|
37 | };
|
38 | return TranslateStaticLoader;
|
39 | }());
|
40 | export var TranslateService = (function () {
|
41 | |
42 |
|
43 |
|
44 |
|
45 |
|
46 |
|
47 | function TranslateService(currentLoader, parser, missingTranslationHandler) {
|
48 | this.currentLoader = currentLoader;
|
49 | this.parser = parser;
|
50 | this.missingTranslationHandler = missingTranslationHandler;
|
51 | |
52 |
|
53 |
|
54 | this.currentLang = this.defaultLang;
|
55 | |
56 |
|
57 |
|
58 |
|
59 |
|
60 |
|
61 |
|
62 | this.onTranslationChange = new EventEmitter();
|
63 | |
64 |
|
65 |
|
66 |
|
67 |
|
68 |
|
69 |
|
70 | this.onLangChange = new EventEmitter();
|
71 | |
72 |
|
73 |
|
74 |
|
75 |
|
76 |
|
77 |
|
78 | this.onDefaultLangChange = new EventEmitter();
|
79 | this.translations = {};
|
80 | this.langs = [];
|
81 | }
|
82 | |
83 |
|
84 |
|
85 |
|
86 | TranslateService.prototype.setDefaultLang = function (lang) {
|
87 | var _this = this;
|
88 | if (lang === this.defaultLang) {
|
89 | return;
|
90 | }
|
91 | var pending = this.retrieveTranslations(lang);
|
92 | if (typeof pending !== "undefined") {
|
93 |
|
94 | if (!this.defaultLang) {
|
95 | this.defaultLang = lang;
|
96 | }
|
97 | pending.take(1)
|
98 | .subscribe(function (res) {
|
99 | _this.changeDefaultLang(lang);
|
100 | });
|
101 | }
|
102 | else {
|
103 | this.changeDefaultLang(lang);
|
104 | }
|
105 | };
|
106 | |
107 |
|
108 |
|
109 |
|
110 | TranslateService.prototype.getDefaultLang = function () {
|
111 | return this.defaultLang;
|
112 | };
|
113 | |
114 |
|
115 |
|
116 |
|
117 |
|
118 | TranslateService.prototype.use = function (lang) {
|
119 | var _this = this;
|
120 | var pending = this.retrieveTranslations(lang);
|
121 | if (typeof pending !== "undefined") {
|
122 |
|
123 | if (!this.currentLang) {
|
124 | this.currentLang = lang;
|
125 | }
|
126 | pending.take(1)
|
127 | .subscribe(function (res) {
|
128 | _this.changeLang(lang);
|
129 | });
|
130 | return pending;
|
131 | }
|
132 | else {
|
133 | this.changeLang(lang);
|
134 | return Observable.of(this.translations[lang]);
|
135 | }
|
136 | };
|
137 | |
138 |
|
139 |
|
140 |
|
141 |
|
142 | TranslateService.prototype.retrieveTranslations = function (lang) {
|
143 | var pending;
|
144 |
|
145 | if (typeof this.translations[lang] === "undefined") {
|
146 | pending = this.getTranslation(lang);
|
147 | }
|
148 | return pending;
|
149 | };
|
150 | |
151 |
|
152 |
|
153 |
|
154 |
|
155 | TranslateService.prototype.getTranslation = function (lang) {
|
156 | var _this = this;
|
157 | this.pending = this.currentLoader.getTranslation(lang).share();
|
158 | this.pending.take(1)
|
159 | .subscribe(function (res) {
|
160 | _this.translations[lang] = res;
|
161 | _this.updateLangs();
|
162 | _this.pending = undefined;
|
163 | }, function (err) {
|
164 | _this.pending = undefined;
|
165 | });
|
166 | return this.pending;
|
167 | };
|
168 | |
169 |
|
170 |
|
171 |
|
172 |
|
173 |
|
174 | TranslateService.prototype.setTranslation = function (lang, translations, shouldMerge) {
|
175 | if (shouldMerge === void 0) { shouldMerge = false; }
|
176 | if (shouldMerge && this.translations[lang]) {
|
177 | Object.assign(this.translations[lang], translations);
|
178 | }
|
179 | else {
|
180 | this.translations[lang] = translations;
|
181 | }
|
182 | this.updateLangs();
|
183 | this.onTranslationChange.emit({ lang: lang, translations: this.translations[lang] });
|
184 | };
|
185 | |
186 |
|
187 |
|
188 |
|
189 | TranslateService.prototype.getLangs = function () {
|
190 | return this.langs;
|
191 | };
|
192 | |
193 |
|
194 |
|
195 |
|
196 | TranslateService.prototype.addLangs = function (langs) {
|
197 | var _this = this;
|
198 | langs.forEach(function (lang) {
|
199 | if (_this.langs.indexOf(lang) === -1) {
|
200 | _this.langs.push(lang);
|
201 | }
|
202 | });
|
203 | };
|
204 | |
205 |
|
206 |
|
207 | TranslateService.prototype.updateLangs = function () {
|
208 | this.addLangs(Object.keys(this.translations));
|
209 | };
|
210 | |
211 |
|
212 |
|
213 |
|
214 |
|
215 |
|
216 |
|
217 | TranslateService.prototype.getParsedResult = function (translations, key, interpolateParams) {
|
218 | var res;
|
219 | if (key instanceof Array) {
|
220 | var result = {}, observables = false;
|
221 | for (var _i = 0, key_1 = key; _i < key_1.length; _i++) {
|
222 | var k = key_1[_i];
|
223 | result[k] = this.getParsedResult(translations, k, interpolateParams);
|
224 | if (typeof result[k].subscribe === "function") {
|
225 | observables = true;
|
226 | }
|
227 | }
|
228 | if (observables) {
|
229 | var mergedObs = void 0;
|
230 | for (var _a = 0, key_2 = key; _a < key_2.length; _a++) {
|
231 | var k = key_2[_a];
|
232 | var obs = typeof result[k].subscribe === "function" ? result[k] : Observable.of(result[k]);
|
233 | if (typeof mergedObs === "undefined") {
|
234 | mergedObs = obs;
|
235 | }
|
236 | else {
|
237 | mergedObs = mergedObs.merge(obs);
|
238 | }
|
239 | }
|
240 | return mergedObs.toArray().map(function (arr) {
|
241 | var obj = {};
|
242 | arr.forEach(function (value, index) {
|
243 | obj[key[index]] = value;
|
244 | });
|
245 | return obj;
|
246 | });
|
247 | }
|
248 | return result;
|
249 | }
|
250 | if (translations) {
|
251 | res = this.parser.interpolate(this.parser.getValue(translations, key), interpolateParams);
|
252 | }
|
253 | if (typeof res === "undefined" && this.defaultLang && this.defaultLang !== this.currentLang) {
|
254 | res = this.parser.interpolate(this.parser.getValue(this.translations[this.defaultLang], key), interpolateParams);
|
255 | }
|
256 | if (!res && this.missingTranslationHandler) {
|
257 | var params = { key: key, translateService: this };
|
258 | if (typeof interpolateParams !== 'undefined') {
|
259 | params.interpolateParams = interpolateParams;
|
260 | }
|
261 | res = this.missingTranslationHandler.handle(params);
|
262 | }
|
263 | return typeof res !== "undefined" ? res : key;
|
264 | };
|
265 | |
266 |
|
267 |
|
268 |
|
269 |
|
270 |
|
271 | TranslateService.prototype.get = function (key, interpolateParams) {
|
272 | var _this = this;
|
273 | if (!isDefined(key) || !key.length) {
|
274 | throw new Error("Parameter \"key\" required");
|
275 | }
|
276 |
|
277 | if (this.pending) {
|
278 | return Observable.create(function (observer) {
|
279 | var onComplete = function (res) {
|
280 | observer.next(res);
|
281 | observer.complete();
|
282 | };
|
283 | var onError = function (err) {
|
284 | observer.error(err);
|
285 | };
|
286 | _this.pending.subscribe(function (res) {
|
287 | res = _this.getParsedResult(res, key, interpolateParams);
|
288 | if (typeof res.subscribe === "function") {
|
289 | res.subscribe(onComplete, onError);
|
290 | }
|
291 | else {
|
292 | onComplete(res);
|
293 | }
|
294 | }, onError);
|
295 | });
|
296 | }
|
297 | else {
|
298 | var res = this.getParsedResult(this.translations[this.currentLang], key, interpolateParams);
|
299 | if (typeof res.subscribe === "function") {
|
300 | return res;
|
301 | }
|
302 | else {
|
303 | return Observable.of(res);
|
304 | }
|
305 | }
|
306 | };
|
307 | |
308 |
|
309 |
|
310 |
|
311 |
|
312 |
|
313 |
|
314 | TranslateService.prototype.instant = function (key, interpolateParams) {
|
315 | if (!isDefined(key) || !key.length) {
|
316 | throw new Error("Parameter \"key\" required");
|
317 | }
|
318 | var res = this.getParsedResult(this.translations[this.currentLang], key, interpolateParams);
|
319 | if (typeof res.subscribe !== "undefined") {
|
320 | if (key instanceof Array) {
|
321 | var obj_1 = {};
|
322 | key.forEach(function (value, index) {
|
323 | obj_1[key[index]] = key[index];
|
324 | });
|
325 | return obj_1;
|
326 | }
|
327 | return key;
|
328 | }
|
329 | else {
|
330 | return res;
|
331 | }
|
332 | };
|
333 | |
334 |
|
335 |
|
336 |
|
337 |
|
338 |
|
339 | TranslateService.prototype.set = function (key, value, lang) {
|
340 | if (lang === void 0) { lang = this.currentLang; }
|
341 | this.translations[lang][key] = value;
|
342 | this.updateLangs();
|
343 | this.onTranslationChange.emit({ lang: lang, translations: this.translations[lang] });
|
344 | };
|
345 | |
346 |
|
347 |
|
348 |
|
349 | TranslateService.prototype.changeLang = function (lang) {
|
350 | this.currentLang = lang;
|
351 | this.onLangChange.emit({ lang: lang, translations: this.translations[lang] });
|
352 |
|
353 | if (!this.defaultLang) {
|
354 | this.changeDefaultLang(lang);
|
355 | }
|
356 | };
|
357 | |
358 |
|
359 |
|
360 |
|
361 | TranslateService.prototype.changeDefaultLang = function (lang) {
|
362 | this.defaultLang = lang;
|
363 | this.onDefaultLangChange.emit({ lang: lang, translations: this.translations[lang] });
|
364 | };
|
365 | |
366 |
|
367 |
|
368 |
|
369 |
|
370 | TranslateService.prototype.reloadLang = function (lang) {
|
371 | this.resetLang(lang);
|
372 | return this.getTranslation(lang);
|
373 | };
|
374 | |
375 |
|
376 |
|
377 |
|
378 | TranslateService.prototype.resetLang = function (lang) {
|
379 | this.translations[lang] = undefined;
|
380 | };
|
381 | |
382 |
|
383 |
|
384 |
|
385 |
|
386 | TranslateService.prototype.getBrowserLang = function () {
|
387 | if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {
|
388 | return undefined;
|
389 | }
|
390 | var browserLang = window.navigator.languages ? window.navigator.languages[0] : null;
|
391 | browserLang = browserLang || window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage;
|
392 | if (browserLang.indexOf('-') !== -1) {
|
393 | browserLang = browserLang.split('-')[0];
|
394 | }
|
395 | if (browserLang.indexOf('_') !== -1) {
|
396 | browserLang = browserLang.split('_')[0];
|
397 | }
|
398 | return browserLang;
|
399 | };
|
400 | |
401 |
|
402 |
|
403 |
|
404 |
|
405 | TranslateService.prototype.getBrowserCultureLang = function () {
|
406 | if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {
|
407 | return undefined;
|
408 | }
|
409 | var browserCultureLang = window.navigator.languages ? window.navigator.languages[0] : null;
|
410 | browserCultureLang = browserCultureLang || window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage;
|
411 | return browserCultureLang;
|
412 | };
|
413 | TranslateService.decorators = [
|
414 | { type: Injectable },
|
415 | ];
|
416 |
|
417 | TranslateService.ctorParameters = function () { return [
|
418 | { type: TranslateLoader, },
|
419 | { type: TranslateParser, },
|
420 | { type: MissingTranslationHandler, decorators: [{ type: Optional },] },
|
421 | ]; };
|
422 | return TranslateService;
|
423 | }());
|