@igo2/core 1.13.0 → 1.13.1

package/fesm2020/igo2-core.mjs

@@ -2,8 +2,8 @@ import * as i0 from '@angular/core';
 import { Injectable, NgModule, InjectionToken, APP_INITIALIZER, Injector, Inject, Optional, SkipSelf, EventEmitter } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { HTTP_INTERCEPTORS, HttpClient, HttpErrorResponse, HttpClientModule, HttpResponse } from '@angular/common/http';
-import { finalize, catchError, map, tap, debounceTime, startWith } from 'rxjs/operators';
-import { BehaviorSubject, throwError, combineLatest, Observable, fromEvent } from 'rxjs';
+import { finalize, catchError, map, debounceTime, first, tap, startWith } from 'rxjs/operators';
+import { BehaviorSubject, throwError, combineLatest, forkJoin, Observable, fromEvent } from 'rxjs';
 import { uuid, ObjectUtils } from '@igo2/utils';
 import * as i1 from '@ngx-translate/core';
 import { TranslateLoader, TranslateModule, MissingTranslationHandler } from '@ngx-translate/core';
@@ -100,8 +100,8 @@ IgoActivityModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
     }], null, null); })();
 
 const version = {
-    lib: '1.13.0',
-    releaseDate: 1665780785791
+    lib: '1.13.1',
+    releaseDate: 1667833050348
 };
 
 class ConfigService {
@@ -337,20 +337,24 @@ var MessageType;
     MessageType["WARNING"] = "warning";
     MessageType["INFO"] = "info";
     MessageType["SUCCESS"] = "success";
+    MessageType["SHOW"] = "show";
 })(MessageType || (MessageType = {}));
 
 class LanguageService {
     constructor(translate) {
         this.translate = translate;
         this.language = this.translate.getBrowserLang();
+        this.language$ = new BehaviorSubject(undefined);
         const lang = this.getLanguage();
         this.translate.setDefaultLang(lang);
+        this.language$.next(lang);
     }
     getLanguage() {
         return this.language.match(/en|fr/) ? this.language : 'en';
     }
     setLanguage(language) {
         this.language = language.match(/en|fr/) ? language : 'en';
+        this.language$.next(this.language);
         this.translate.use(this.language);
         this.translate.reloadLang(this.language);
     }
@@ -370,7 +374,39 @@ class MessageService {
         this.configService = configService;
         this.languageService = languageService;
         this.messages$ = new BehaviorSubject([]);
+        this.activeMessageTranslations = [];
         this.options = this.configService.getConfig('message') || {};
+        this.languageService.language$.pipe(debounceTime(500)).subscribe(r => {
+            if (this.toastr.toasts.length === 0) {
+                this.activeMessageTranslations = [];
+            }
+            this.toastr.toasts.map(toast => {
+                const activeMessageTranslation = this.activeMessageTranslations.find(amt => amt.id === toast.toastId);
+                if (activeMessageTranslation) {
+                    const translatedTextInterpolateParams = { ...activeMessageTranslation.textInterpolateParams };
+                    const translatedTitleInterpolateParams = { ...activeMessageTranslation.titleInterpolateParams };
+                    if (activeMessageTranslation.textInterpolateParams) {
+                        Object.keys(activeMessageTranslation.textInterpolateParams).map(k => {
+                            translatedTextInterpolateParams[k] =
+                                this.languageService.translate.instant(activeMessageTranslation.textInterpolateParams[k]);
+                        });
+                    }
+                    if (activeMessageTranslation.titleInterpolateParams) {
+                        Object.keys(activeMessageTranslation.titleInterpolateParams).map(k => {
+                            translatedTitleInterpolateParams[k] =
+                                this.languageService.translate.instant(activeMessageTranslation.titleInterpolateParams[k]);
+                        });
+                    }
+                    forkJoin([
+                        this.languageService.translate.get(activeMessageTranslation.textKey, translatedTextInterpolateParams),
+                        this.languageService.translate.get(activeMessageTranslation.titleKey, translatedTitleInterpolateParams)
+                    ]).pipe(first()).subscribe((res) => {
+                        toast.toastRef.componentInstance.message = res[0];
+                        toast.toastRef.componentInstance.title = res[1];
+                    });
+                }
+            });
+        });
     }
     get toastr() {
         return this.injector.get(ToastrService);
@@ -380,6 +416,8 @@ class MessageService {
         return this.error(httpError.error.message, httpError.error.title);
     }
     message(message) {
+        const messageType = message.type;
+        this.toastr.toastrConfig.iconClasses[messageType] = `toast-${messageType}`;
         this.messages$.next(this.messages$.value.concat([message]));
         message.options = message.options || {};
         const currentDate = new Date();
@@ -392,50 +430,93 @@ class MessageService {
             message.options.to = new Date(Date.parse(message.options.to.replace(/-/g, ' ')));
         }
         if (currentDate > message.options.from && currentDate < message.options.to) {
+            if (message.showIcon === false) {
+                this.toastr.toastrConfig.iconClasses[messageType] = `toast-${messageType} toast-no-icon`;
+            }
             message = this.handleTemplate(message);
             if (message.text) {
                 let messageShown;
                 switch (message.type) {
                     case MessageType.SUCCESS:
-                        messageShown = this.success(message.text, message.title, message.options);
+                        messageShown = this.success(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
                         break;
                     case MessageType.ERROR:
-                        messageShown = this.error(message.text, message.title, message.options);
+                        messageShown = this.error(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
                         break;
                     case MessageType.INFO:
-                        messageShown = this.info(message.text, message.title, message.options);
+                        messageShown = this.info(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                    case MessageType.SHOW:
+                        messageShown = this.show(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
                         break;
                     case MessageType.ALERT:
                     case MessageType.WARNING:
-                        messageShown = this.alert(message.text, message.title, message.options);
+                        messageShown = this.alert(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
                         break;
                     default:
-                        messageShown = this.info(message.text, message.title, message.options);
+                        messageShown = this.info(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
                         break;
                 }
                 message.options.id = messageShown.toastId;
             }
         }
     }
-    success(text, title = 'igo.core.message.success', options = {}) {
-        const message = this.languageService.translate.instant(text);
-        const translatedTitle = this.languageService.translate.instant(title);
-        return this.toastr.success(message, translatedTitle, options);
+    success(text, title = 'igo.core.message.success', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('success', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    error(text, title = 'igo.core.message.error', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('error', text, title, options, textInterpolateParams, titleInterpolateParams);
     }
-    error(text, title = 'igo.core.message.error', options = {}) {
-        const message = this.languageService.translate.instant(text);
-        const translatedTitle = this.languageService.translate.instant(title);
-        return this.toastr.error(message, translatedTitle, options);
+    info(text, title = 'igo.core.message.info', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('info', text, title, options, textInterpolateParams, titleInterpolateParams);
     }
-    info(text, title = 'igo.core.message.info', options = {}) {
-        const message = this.languageService.translate.instant(text);
-        const translatedTitle = this.languageService.translate.instant(title);
-        return this.toastr.info(message, translatedTitle, options);
+    alert(text, title = 'igo.core.message.alert', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('alert', text, title, options, textInterpolateParams, titleInterpolateParams);
     }
-    alert(text, title = 'igo.core.message.alert', options = {}) {
-        const message = this.languageService.translate.instant(text);
-        const translatedTitle = this.languageService.translate.instant(title);
-        return this.toastr.warning(message, translatedTitle, options);
+    show(text, title = 'igo.core.message.info', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('show', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    handleNgxToastr(type, text, title, options = {}, textInterpolateParams, titleInterpolateParams) {
+        const translatedTextInterpolateParams = { ...textInterpolateParams };
+        const translatedTitlenterpolateParams = { ...titleInterpolateParams };
+        if (textInterpolateParams) {
+            Object.keys(textInterpolateParams).map(k => {
+                translatedTextInterpolateParams[k] =
+                    this.languageService.translate.instant(textInterpolateParams[k]);
+            });
+        }
+        if (titleInterpolateParams) {
+            Object.keys(titleInterpolateParams).map(k => {
+                translatedTitlenterpolateParams[k] =
+                    this.languageService.translate.instant(titleInterpolateParams[k]);
+            });
+        }
+        const message = this.languageService.translate.instant(text, translatedTextInterpolateParams);
+        const translatedTitle = this.languageService.translate.instant(title, translatedTitlenterpolateParams);
+        let activeToast;
+        switch (type) {
+            case 'success':
+                activeToast = this.toastr.success(message, translatedTitle, options);
+                break;
+            case 'error':
+                activeToast = this.toastr.error(message, translatedTitle, options);
+                break;
+            case 'show':
+            case 'info':
+                activeToast = this.toastr.info(message, translatedTitle, options);
+                break;
+            case 'alert':
+                activeToast = this.toastr.warning(message, translatedTitle, options);
+                break;
+        }
+        this.activeMessageTranslations.push({
+            id: activeToast.toastId,
+            titleKey: title,
+            textKey: text,
+            textInterpolateParams,
+            titleInterpolateParams
+        });
+        return activeToast;
     }
     remove(id) {
         this.toastr.remove(id);
@@ -476,7 +557,14 @@ class ErrorInterceptor {
     constructor(injector) {
         this.injector = injector;
     }
-    intercept(req, next) {
+    intercept(originalReq, next) {
+        const interceptError = originalReq.headers.get('interceptError');
+        const req = originalReq.clone({
+            headers: originalReq.headers.delete('interceptError')
+        });
+        if (interceptError === 'false') {
+            return next.handle(req);
+        }
         const errorContainer = { httpError: undefined };
         return next.handle(req).pipe(catchError(error => this.handleError(error, errorContainer)), finalize(() => {
             this.handleCaughtError(errorContainer);