monkey-front-core 0.0.36 → 0.0.40

package/esm2020/lib/core/services/config/monkeyecx-error-config.service.mjs

@@ -0,0 +1,85 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+let window;
+const text = {
+    i18n: {
+        title: 'We have an quick update for you',
+        message: 'Click anywhere here to reload your locale',
+    },
+    theme: {
+        title: 'We have an quick update for you',
+        message: 'Click anywhere here to reload your theme',
+    },
+};
+export class MonkeyEcxErrorConfigService {
+    constructor() {
+        // not to do
+    }
+    enableSupport() {
+        window.zE('webWidget', 'updateSettings', {
+            webWidget: {
+                color: {
+                    theme: '#0273E8',
+                    launcherText: '#fff',
+                    header: '#0273E8',
+                    button: '#0273E8',
+                },
+                zIndex: 99,
+                offset: {
+                    horizontal: '1px',
+                    vertical: '20px',
+                },
+                mobile: {
+                    labelVisible: true,
+                },
+                launcher: {
+                    mobile: {
+                        labelVisible: true,
+                    },
+                },
+            },
+        });
+        window.zE('webWidget', 'setLocale', 'en-US');
+        window.zE('webWidget', 'show');
+    }
+    apply(type) {
+        const { title, message } = text?.[type];
+        const element = document.createElement('div');
+        element.id = 'monkeyecx-information';
+        const elementImg = document.createElement('img');
+        elementImg.width = 128;
+        elementImg.src = 'assets/images/monkey.svg';
+        elementImg.style.marginBottom = '50px';
+        const elementTitle = document.createElement('span');
+        elementTitle.id = 'title';
+        elementTitle.innerText = title;
+        elementTitle.style.marginBottom = '20px';
+        const elementMessage = document.createElement('span');
+        elementMessage.id = 'message';
+        elementMessage.innerText = message;
+        elementMessage.style.marginBottom = '20px';
+        const elementChat = document.createElement('span');
+        elementChat.id = 'message';
+        elementChat.innerText =
+            "If you're having trouble to update, please use the support icon bellow";
+        element.appendChild(elementImg);
+        element.appendChild(elementTitle);
+        element.appendChild(elementMessage);
+        element.appendChild(elementChat);
+        element.addEventListener('click', () => {
+            document.location.reload();
+        });
+        document.body.appendChild(element);
+        document.body.getElementsByTagName('app-root')[0].remove();
+        this.enableSupport();
+    }
+}
+MonkeyEcxErrorConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxErrorConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/config/monkeyecx-feature-toggle.service.mjs

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { initialize } from 'launchdarkly-js-client-sdk';
+import { MonkeyUtils } from 'monkey-style-guide';
+import * as i0 from "@angular/core";
+export class MonkeyEcxFeatureToggleService {
+    constructor() {
+        this.flagSubject$ = new BehaviorSubject(null);
+        this.flags = undefined;
+        this.ldClient = undefined;
+        // not to do
+    }
+    getAllFlags() {
+        this.flags = this.ldClient?.allFlags();
+        this.flagSubject$.next(true);
+    }
+    identify(config, environment) {
+        if (config) {
+            const email = 'monkey@monkey.exchange';
+            const user = {
+                email,
+                key: `${config.program?.token}#${email}`
+            };
+            if (!this.ldClient) {
+                this.ldClient = initialize(environment.launchDarklyClientSideID, user, {
+                    streaming: true,
+                    disableSyncEventPost: true,
+                    sendEvents: false,
+                    diagnosticOptOut: true
+                });
+                this.ldClient.on('change', this.getAllFlags.bind(this));
+                this.ldClient.on('ready', this.getAllFlags.bind(this));
+            }
+            else {
+                this.ldClient.identify(user, undefined, this.getAllFlags);
+            }
+        }
+    }
+    apply(configSubject$, environment) {
+        if (environment.launchDarklyClientSideID) {
+            configSubject$.subscribe((config) => {
+                this.identify(config, environment);
+            });
+        }
+        else {
+            this.flagSubject$.next(true);
+        }
+    }
+    get onFlags() {
+        return this.flagSubject$.asObservable();
+    }
+    getFlag(flag) {
+        const flagValue = this.flags?.[flag];
+        return MonkeyUtils.persistNullEmptyUndefined(flagValue) ? flagValue : null;
+    }
+}
+MonkeyEcxFeatureToggleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxFeatureToggleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxFeatureToggleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxFeatureToggleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxFeatureToggleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/config/monkeyecx-i18n-config.service.mjs

@@ -0,0 +1,66 @@
+import { __decorate } from "tslib";
+/* eslint-disable no-console */
+/* eslint-disable import/no-named-default */
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { MonkeyEcxCoreService } from '../../decorators/monkeyecx-decorators';
+import { MonkeyEcxCommonsService } from '../commons';
+import * as i0 from "@angular/core";
+import * as i1 from "../monkeyecx-service.service";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "../storage/monkeyecx-cookie-storage.service";
+import * as i4 from "../config/monkeyecx-error-config.service";
+export class MonkeyEcxi18nConfigService extends MonkeyEcxCommonsService {
+    constructor(monkeyecxService, translateService, monkeyecxCookieStorageService, monkeyecxErrorConfigService) {
+        super(monkeyecxService);
+        this.translateService = translateService;
+        this.monkeyecxCookieStorageService = monkeyecxCookieStorageService;
+        this.monkeyecxErrorConfigService = monkeyecxErrorConfigService;
+        this.translateService.addLangs(['pt-BR', 'en-US']);
+        this.translateService.setDefaultLang('pt-BR');
+        this.translateService.use('pt-BR');
+    }
+    apply(params, environment, change = false) {
+        const { monkeyecxService, monkeyecxCookieStorageService, monkeyecxErrorConfigService } = this;
+        let { i18n } = params;
+        const cookie = monkeyecxCookieStorageService.getCookie('monkey-app-locale');
+        if (cookie && !change) {
+            i18n = JSON.parse(atob(cookie));
+        }
+        else {
+            monkeyecxCookieStorageService.setCookie('monkey-app-locale', btoa(JSON.stringify(i18n)));
+            if (!cookie)
+                change = true;
+        }
+        monkeyecxService?.get(`${environment.localAssets}/i18n/${i18n?.lang}.json`)?.subscribe((config) => {
+            const { lang, data } = config;
+            this.translateService.setTranslation(lang, data, true);
+            this.translateService.use(lang);
+            if (change)
+                document.location.reload();
+        }, (err) => {
+            console.error(`i18n ${i18n?.lang} not found!`);
+            monkeyecxErrorConfigService.apply('i18n');
+            throwError(err);
+        });
+    }
+}
+MonkeyEcxi18nConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxi18nConfigService, deps: [{ token: i1.MonkeyEcxService }, { token: i2.TranslateService }, { token: i3.MonkeyEcxCookieStorageService }, { token: i4.MonkeyEcxErrorConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxi18nConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxi18nConfigService, providedIn: 'root' });
+__decorate([
+    MonkeyEcxCoreService({
+        httpResponse: {
+            httpCodeIgnore: [404]
+        },
+        requestInProgress: {
+            showProgress: false
+        }
+    })
+], MonkeyEcxi18nConfigService.prototype, "apply", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxi18nConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MonkeyEcxService }, { type: i2.TranslateService }, { type: i3.MonkeyEcxCookieStorageService }, { type: i4.MonkeyEcxErrorConfigService }]; }, propDecorators: { apply: [] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/config/monkeyecx-logs-config.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { datadogRum } from '@datadog/browser-rum';
+import * as i0 from "@angular/core";
+export class MonkeyEcxLogsConfigService {
+    apply(params, configBoostrap, environment, identifyCode) {
+        const { program, logs } = params;
+        if (logs?.enabled && environment.environment !== 'dev') {
+            datadogRum.init({
+                applicationId: environment?.dataDogApplicationId,
+                clientToken: environment?.dataDogClientToken,
+                service: program?.token,
+                site: 'datadoghq.com',
+                sampleRate: 100,
+                replaySampleRate: 100,
+                env: `monkey-front-${identifyCode}-${environment.environment}`,
+                version: configBoostrap?.version,
+                trackInteractions: true,
+                trackSessionAcrossSubdomains: true,
+                useSecureSessionCookie: true,
+                useCrossSiteSessionCookie: true
+            });
+            datadogRum.startSessionReplayRecording();
+        }
+    }
+}
+MonkeyEcxLogsConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxLogsConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxLogsConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxLogsConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxLogsConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/core/services/config/monkeyecx-maintenance-config.service.js → esm2020/lib/core/services/config/monkeyecx-maintenance-config.service.mjs}

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core';
-import { ClosedToMaintenanceComponent } from '../../../components/closed-to-maintenance';
+import { ClosedToMaintenanceComponent } from '../../../components/closed-to-maintenance/closed-to-maintenance.component';
 import * as i0 from "@angular/core";
 import * as i1 from "monkey-style-guide";
 import * as i2 from "@angular/router";
@@ -26,12 +26,12 @@ export class MonkeyEcxMaintenanceConfigService {
         this.handleValidation(config);
     }
 }
-MonkeyEcxMaintenanceConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxMaintenanceConfigService, deps: [{ token: i1.MonkeyStyleGuideModalService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-MonkeyEcxMaintenanceConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxMaintenanceConfigService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxMaintenanceConfigService, decorators: [{
+MonkeyEcxMaintenanceConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxMaintenanceConfigService, deps: [{ token: i1.MonkeyStyleGuideModalService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxMaintenanceConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxMaintenanceConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxMaintenanceConfigService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.MonkeyStyleGuideModalService }, { type: i2.Router }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/config/monkeyecx-security-console-config.service.mjs

@@ -0,0 +1,42 @@
+/* eslint-disable no-console */
+import { Injectable } from '@angular/core';
+import { MonkeyEcxCommonsService } from '../commons';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class MonkeyEcxSecurityConsoleConfigService extends MonkeyEcxCommonsService {
+    constructor(translateService) {
+        super();
+        this.translateService = translateService;
+        this.geti18n(this.translateService, 'SERVICES.WARNING.CONSOLE');
+    }
+    handleValidation() {
+        this.__oni18nDataChanged$.subscribe(() => {
+            const { __i18n } = this;
+            const title = __i18n?.TITLE;
+            const message = __i18n?.MESSAGE;
+            if (title) {
+                console.log(`%c${title}`, 'background: #f2f061; color: #ff0000; font-size: x-large');
+                console.log(`%c${message}`, 'font-size: x-large');
+                console.log('%c  __  __             _             ______   \n ' +
+                    '|  \\/  | ___  _ __ | | _____ _   _\\ \\ \\ \\  \n ' +
+                    "| |\\/| |/ _ \\| '_ \\| |/ / _ \\ | | |\\ \\ \\ \\ \n " +
+                    '| |  | | (_) | | | |   <  __/ |_| |/ / / / \n ' +
+                    '|_|  |_|\\___/|_| |_|_|\\_\\___|\\__, /_/_/_/  \n ' +
+                    '                             |___/         \n ' +
+                    'Join us: https://monkeyecx.gupy.io', 'background: #1976d2; color: #fff');
+            }
+        });
+    }
+    apply() {
+        this.handleValidation();
+    }
+}
+MonkeyEcxSecurityConsoleConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxSecurityConsoleConfigService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxSecurityConsoleConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxSecurityConsoleConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxSecurityConsoleConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/config/monkeyecx-service-worker-config.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { concat, interval } from 'rxjs';
+import { first } from 'rxjs/operators';
+import { VersionChangedComponent } from '../../../components/version-changed';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/service-worker";
+import * as i2 from "monkey-style-guide";
+export class MonkeyEcxServiceWorkerConfigService {
+    constructor(appRef, updates, modalService) {
+        this.appRef = appRef;
+        this.updates = updates;
+        this.modalService = modalService;
+        // not to do
+    }
+    handleValidation(config) {
+        const { updates, modalService } = this;
+        updates?.versionUpdates?.subscribe(() => {
+            if (!config.showNewVersion || config.maintenance.closed) {
+                document.location.reload();
+            }
+            else {
+                modalService.open(VersionChangedComponent, {
+                    color: 'theme',
+                    size: 'md'
+                });
+            }
+        });
+    }
+    verify() {
+        const { appRef, updates } = this;
+        const appIsStable$ = appRef.isStable
+            .pipe(first((isStable) => { return isStable === true; }));
+        const everyHour$ = interval(1 * 60 * 60 * 1000);
+        const everyHourOnceAppIsStable$ = concat(appIsStable$, everyHour$);
+        everyHourOnceAppIsStable$.subscribe(() => {
+            updates.checkForUpdate();
+        });
+        updates.checkForUpdate();
+    }
+    apply(config) {
+        this.handleValidation(config);
+        this.verify();
+    }
+}
+MonkeyEcxServiceWorkerConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxServiceWorkerConfigService, deps: [{ token: i0.ApplicationRef }, { token: i1.SwUpdate }, { token: i2.MonkeyStyleGuideModalService }], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxServiceWorkerConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxServiceWorkerConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxServiceWorkerConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ApplicationRef }, { type: i1.SwUpdate }, { type: i2.MonkeyStyleGuideModalService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/core/services/error/index.js → esm2020/lib/core/services/error/index.mjs}

@@ -2,4 +2,4 @@ export * from './monkeyecx-error-handling.module';
 export * from './monkeyecx-error-handling.service';
 export * from './monkeyecx-http-error-handling.service';
 export * from './monkeyecx-others-errors-handling.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29yZS9zcmMvbGliL2NvcmUvc2VydmljZXMvZXJyb3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyw0Q0FBNEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LWVycm9yLWhhbmRsaW5nLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LWVycm9yLWhhbmRsaW5nLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1odHRwLWVycm9yLWhhbmRsaW5nLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1vdGhlcnMtZXJyb3JzLWhhbmRsaW5nLnNlcnZpY2UnO1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29yZS9zcmMvbGliL2NvcmUvc2VydmljZXMvZXJyb3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyw0Q0FBNEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LWVycm9yLWhhbmRsaW5nLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1lcnJvci1oYW5kbGluZy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9ua2V5ZWN4LWh0dHAtZXJyb3ItaGFuZGxpbmcuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL21vbmtleWVjeC1vdGhlcnMtZXJyb3JzLWhhbmRsaW5nLnNlcnZpY2UnO1xuIl19

package/{esm2015/lib/core/services/error/monkeyecx-error-handling.module.js → esm2020/lib/core/services/error/monkeyecx-error-handling.module.mjs}

@@ -15,13 +15,13 @@ export class MonkeyEcxErrorHandlingModule {
         };
     }
 }
-MonkeyEcxErrorHandlingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxErrorHandlingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-MonkeyEcxErrorHandlingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxErrorHandlingModule, imports: [CommonModule] });
-MonkeyEcxErrorHandlingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxErrorHandlingModule, imports: [[CommonModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: MonkeyEcxErrorHandlingModule, decorators: [{
+MonkeyEcxErrorHandlingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MonkeyEcxErrorHandlingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingModule, imports: [CommonModule] });
+MonkeyEcxErrorHandlingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ua2V5ZWN4LWVycm9yLWhhbmRsaW5nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21vbmtleS1mcm9udC1jb3JlL3NyYy9saWIvY29yZS9zZXJ2aWNlcy9lcnJvci9tb25rZXllY3gtZXJyb3ItaGFuZGxpbmcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQzs7QUFLbkYsTUFBTSxPQUFPLDRCQUE0QjtJQUNoQyxNQUFNLENBQUMsT0FBTztRQUNuQixPQUFPO1lBQ0wsUUFBUSxFQUFFLDRCQUE0QjtZQUN0QyxTQUFTLEVBQUU7Z0JBQ1Q7b0JBQ0UsT0FBTyxFQUFFLFlBQVk7b0JBQ3JCLFFBQVEsRUFBRSw2QkFBNkI7aUJBQ3hDO2FBQ0Y7U0FDRixDQUFDO0lBQ0osQ0FBQzs7MEhBWFUsNEJBQTRCOzJIQUE1Qiw0QkFBNEIsWUFGN0IsWUFBWTsySEFFWCw0QkFBNEIsWUFGOUIsQ0FBQyxZQUFZLENBQUM7NEZBRVosNEJBQTRCO2tCQUh4QyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztpQkFDeEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFcnJvckhhbmRsZXIsIE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE1vZHVsZVdpdGhQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb21waWxlci9zcmMvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IE1vbmtleUVjeEVycm9ySGFuZGxpbmdTZXJ2aWNlIH0gZnJvbSAnLi9tb25rZXllY3gtZXJyb3ItaGFuZGxpbmcuc2VydmljZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBNb25rZXlFY3hFcnJvckhhbmRsaW5nTW9kdWxlIHtcclxuICBwdWJsaWMgc3RhdGljIGZvclJvb3QoKTogTW9kdWxlV2l0aFByb3ZpZGVycyB7XHJcbiAgICByZXR1cm4ge1xyXG4gICAgICBuZ01vZHVsZTogTW9ua2V5RWN4RXJyb3JIYW5kbGluZ01vZHVsZSxcclxuICAgICAgcHJvdmlkZXJzOiBbXHJcbiAgICAgICAge1xyXG4gICAgICAgICAgcHJvdmlkZTogRXJyb3JIYW5kbGVyLFxyXG4gICAgICAgICAgdXNlQ2xhc3M6IE1vbmtleUVjeEVycm9ySGFuZGxpbmdTZXJ2aWNlXHJcbiAgICAgICAgfVxyXG4gICAgICBdXHJcbiAgICB9O1xyXG4gIH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ua2V5ZWN4LWVycm9yLWhhbmRsaW5nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21vbmtleS1mcm9udC1jb3JlL3NyYy9saWIvY29yZS9zZXJ2aWNlcy9lcnJvci9tb25rZXllY3gtZXJyb3ItaGFuZGxpbmcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQzs7QUFLbkYsTUFBTSxPQUFPLDRCQUE0QjtJQUNoQyxNQUFNLENBQUMsT0FBTztRQUNuQixPQUFPO1lBQ0wsUUFBUSxFQUFFLDRCQUE0QjtZQUN0QyxTQUFTLEVBQUU7Z0JBQ1Q7b0JBQ0UsT0FBTyxFQUFFLFlBQVk7b0JBQ3JCLFFBQVEsRUFBRSw2QkFBNkI7aUJBQ3hDO2FBQ0Y7U0FDRixDQUFDO0lBQ0osQ0FBQzs7eUhBWFUsNEJBQTRCOzBIQUE1Qiw0QkFBNEIsWUFGN0IsWUFBWTswSEFFWCw0QkFBNEIsWUFGOUIsQ0FBQyxZQUFZLENBQUM7MkZBRVosNEJBQTRCO2tCQUh4QyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztpQkFDeEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFcnJvckhhbmRsZXIsIE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNb2R1bGVXaXRoUHJvdmlkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29tcGlsZXIvc3JjL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1vbmtleUVjeEVycm9ySGFuZGxpbmdTZXJ2aWNlIH0gZnJvbSAnLi9tb25rZXllY3gtZXJyb3ItaGFuZGxpbmcuc2VydmljZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdXG59KVxuZXhwb3J0IGNsYXNzIE1vbmtleUVjeEVycm9ySGFuZGxpbmdNb2R1bGUge1xuICBwdWJsaWMgc3RhdGljIGZvclJvb3QoKTogTW9kdWxlV2l0aFByb3ZpZGVycyB7XG4gICAgcmV0dXJuIHtcbiAgICAgIG5nTW9kdWxlOiBNb25rZXlFY3hFcnJvckhhbmRsaW5nTW9kdWxlLFxuICAgICAgcHJvdmlkZXJzOiBbXG4gICAgICAgIHtcbiAgICAgICAgICBwcm92aWRlOiBFcnJvckhhbmRsZXIsXG4gICAgICAgICAgdXNlQ2xhc3M6IE1vbmtleUVjeEVycm9ySGFuZGxpbmdTZXJ2aWNlXG4gICAgICAgIH1cbiAgICAgIF1cbiAgICB9O1xuICB9XG59XG4iXX0=

package/esm2020/lib/core/services/error/monkeyecx-error-handling.service.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { MonkeyEcxHttpErrorHandlingService } from './monkeyecx-http-error-handling.service';
+import { MonkeyEcxHandlingService } from '../monkeyecx-handling.service';
+import { MonkeyEcxOthersErrorsHandlingService } from './monkeyecx-others-errors-handling.service';
+import { MonkeyEcxUtils } from '../../utils/utils';
+import * as i0 from "@angular/core";
+export class MonkeyEcxErrorHandlingService {
+    constructor(injector) {
+        this.injector = injector;
+        // not to do
+    }
+    handleError(error, type) {
+        const { injector } = this;
+        const handlingService = injector.get(MonkeyEcxHandlingService);
+        const httpErrorHandlingService = injector.get(MonkeyEcxHttpErrorHandlingService);
+        const othersErrorsHandlingService = injector.get(MonkeyEcxOthersErrorsHandlingService);
+        console.log('======error');
+        console.log(error);
+        if (error instanceof HttpErrorResponse) {
+            const sCredentials = handlingService?.getMonkeyEcxServiceCredentials() || {};
+            console.log('sCredentials');
+            console.log(sCredentials);
+            if (MonkeyEcxUtils.persistNullEmptyUndefined(type) && type === 'refresh_token') {
+                httpErrorHandlingService.handleErrorRefreshToken(error, sCredentials);
+            }
+            else
+                httpErrorHandlingService.handleError(error, sCredentials);
+        }
+        else {
+            othersErrorsHandlingService.handleError(error);
+        }
+    }
+}
+MonkeyEcxErrorHandlingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+MonkeyEcxErrorHandlingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MonkeyEcxErrorHandlingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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