new-front-common-library 16.1.32-ROY-3 → 16.1.32-ROY-4

package/esm2022/lib/util/services/storage/local-storage.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../event/storage/local-storage-events.service";
+export class LocalStorageService {
+    constructor(localStorageEvents) {
+        this.localStorageEvents = localStorageEvents;
+    }
+    // Check if the data exist in the session storage
+    exist(key) {
+        return localStorage.hasOwnProperty(key);
+    }
+    get(key) {
+        return this.exist(key) ? JSON.parse(localStorage.getItem(key)) : null;
+    }
+    post(key, data) {
+        localStorage.setItem(key, JSON.stringify(data));
+        this.localStorageEvents.emitLocalStorageEvent();
+    }
+    // check if the key exist in the local storage and if it equals to the value param
+    contains(key, data) {
+        return localStorage.getItem(key).indexOf(JSON.stringify(data)) !== -1 ? true : false;
+    }
+    delete(key) {
+        if (this.exist(key)) {
+            localStorage.removeItem(key);
+            return true;
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageService, deps: [{ token: i1.LocalStorageEventsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LocalStorageEventsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/services/storage/session-storage.service.mjs

@@ -0,0 +1,38 @@
+// Angular 2
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../event/storage/session-storage-events.service";
+// Services
+export class SessionStorageService {
+    constructor(sessionsStorageEvents) {
+        this.sessionsStorageEvents = sessionsStorageEvents;
+    }
+    // Check if the data exist in the session storage
+    exist(key) {
+        return (undefined !== sessionStorage.getItem(key) && null !== sessionStorage.getItem(key)) ? true : false;
+    }
+    get(key) {
+        return this.exist(key) ? JSON.parse(sessionStorage.getItem(key)) : null;
+    }
+    post(key, data) {
+        sessionStorage.setItem(key, JSON.stringify(data));
+        this.sessionsStorageEvents.emitUpdate();
+    }
+    // check if the key exist in the session storage and if it equals to the value param
+    contains(key, data) {
+        return this.get(key).indexOf(JSON.stringify(data)) !== -1 ? true : false;
+    }
+    delete(key) {
+        if (this.exist(key)) {
+            sessionStorage.removeItem(key);
+            return true;
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SessionStorageService, deps: [{ token: i1.SessionStorageEventsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SessionStorageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SessionStorageEventsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/services/translate-language/lang.service.mjs

@@ -0,0 +1,31 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../storage/local-storage.service";
+export class LangService {
+    constructor(translate, localStorage) {
+        this.translate = translate;
+        this.localStorage = localStorage;
+        this.switchLangEmitter = new EventEmitter();
+    }
+    translateLanguage() {
+        this.translate.addLangs(['en', 'fr', 'de']);
+        if (this.localStorage.exist('lang') && this.translate.getLangs().indexOf(this.localStorage.get('lang')) != -1) {
+            this.translate.use(this.localStorage.get('lang'));
+        }
+        else {
+            this.translate.use(this.translate.getLangs().indexOf(this.translate.getBrowserLang()) != -1 ? this.translate.getBrowserLang() : 'en');
+        }
+        this.localStorage.post('lang', this.translate.currentLang);
+    }
+    // emit an event when local storage change
+    switchLang() {
+        this.switchLangEmitter.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LangService, deps: [{ token: i1.TranslateService }, { token: i2.LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LangService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LangService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.LocalStorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/services/user/user-subsidiary.service.mjs

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { Family } from '../../enums/family.enum';
+import { User } from '../../decorators/user.decorator';
+import * as i0 from "@angular/core";
+export class UserSubsidiaryService {
+    isCanalPlusInternationalUser() {
+        return this.user?.subsidiaries?.length > 0 && this.user.subsidiaries.every((value) => value.family?.label === Family.CANAL_PLUS_INTERNATIONAL.valueOf());
+    }
+    isStudiocanalUser() {
+        return this.user?.subsidiaries?.length > 0 && this.user?.subsidiaries?.some((value) => value.family?.label === Family.STUDIOCANAL.valueOf());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserSubsidiaryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserSubsidiaryService }); }
+}
+__decorate([
+    User()
+], UserSubsidiaryService.prototype, "user", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserSubsidiaryService, decorators: [{
+            type: Injectable
+        }], propDecorators: { user: [] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/sort.mjs

@@ -0,0 +1,22 @@
+export class SortBy {
+    // Function which sorts by no matter which field, in ascending and in descending order
+    // The last parameter is optional and is a mapper.
+    // Example of call :
+    // --> exampleArray.sort(sort_by('id', true, parseInt)); -Sort the elements in ascending order by id.
+    // If the id is not an integer and is for example a string, we may give a parameter the parseInt function
+    // to do the conversion.
+    constructor() {
+        // -->exampleArray.(sort_by('name', false, (a) =>{return a.toUpperCase()})); Sort the elements by name (case insensitive)
+        this.sortByField = (field, ascending, functionToApply) => {
+            let convertField = x => {
+                return functionToApply ? functionToApply(x[field]) : x[field];
+            };
+            return (a, b) => {
+                let A = convertField(a);
+                let B = convertField(b);
+                return (A < B ? -1 : A > B ? 1 : 0) * [-1, 1][+!!ascending];
+            };
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/theme/theme-event.service.mjs

@@ -0,0 +1,17 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ThemeEventsService {
+    constructor() {
+        this.switchThemeEmitter = new EventEmitter();
+    }
+    // emit an event when local storage change
+    switchTheme() {
+        this.switchThemeEmitter.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ThemeEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ThemeEventsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ThemeEventsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtZXZlbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25ldy1mcm9udC1jb21tb24tbGlicmFyeS9zcmMvbGliL3V0aWwvdGhlbWUvdGhlbWUtZXZlbnQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHekQsTUFBTSxPQUFPLGtCQUFrQjtJQUkzQjtRQUZPLHVCQUFrQixHQUFzQixJQUFJLFlBQVksRUFBRSxDQUFDO0lBR2xFLENBQUM7SUFFRCwwQ0FBMEM7SUFDbkMsV0FBVztRQUNkLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNuQyxDQUFDOytHQVZRLGtCQUFrQjttSEFBbEIsa0JBQWtCOzs0RkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBUaGVtZUV2ZW50c1NlcnZpY2Uge1xuXG4gICAgcHVibGljIHN3aXRjaFRoZW1lRW1pdHRlcjogRXZlbnRFbWl0dGVyPGFueT4gPSBuZXcgRXZlbnRFbWl0dGVyKCk7XG5cbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICB9XG5cbiAgICAvLyBlbWl0IGFuIGV2ZW50IHdoZW4gbG9jYWwgc3RvcmFnZSBjaGFuZ2VcbiAgICBwdWJsaWMgc3dpdGNoVGhlbWUoKSB7XG4gICAgICAgIHRoaXMuc3dpdGNoVGhlbWVFbWl0dGVyLmVtaXQoKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/util/toaster/toaster-events.service.mjs

@@ -0,0 +1,32 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ToasterEventsService {
+    constructor() {
+        this.toasterSuccessEvent = new EventEmitter();
+        this.toasterErrorEvent = new EventEmitter();
+        this.toasterWarnEvent = new EventEmitter();
+        this.toasterInfoEvent = new EventEmitter();
+    }
+    // emit a success event toaster
+    successEvent(message) {
+        this.toasterSuccessEvent.emit(message);
+    }
+    // emit a success event toaster
+    errorEvent(message) {
+        this.toasterErrorEvent.emit(message);
+    }
+    // emit a success event toaster
+    warnEvent(message) {
+        this.toasterWarnEvent.emit(message);
+    }
+    // emit a success event toaster
+    infoEvent(message) {
+        this.toasterInfoEvent.emit(message);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToasterEventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToasterEventsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ToasterEventsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/util.module.mjs

@@ -0,0 +1,281 @@
+import { DEFAULT_WEB_CONFIG, WEB_CONFIG } from './config';
+// Angular
+import { NgModule } from '@angular/core';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { CommonModule, CurrencyPipe, DatePipe } from '@angular/common';
+// Services
+import { CommonApiService } from './services/api/common-api.service';
+// Modules
+import { LocalStorageService } from './services/storage/local-storage.service';
+import { InterceptorHttpService } from './services/jwt-security/interceptorhttp.service';
+import { MyNumberFormatterDirective } from './directives/my-number-formatter-directive';
+import { CapitalizefirstPipe } from './pipes/capitalizefirst.pipe';
+import { SpacesNumberPipe } from './pipes/comma-separated-number.pipe';
+import { SanitizeHtml } from './pipes/display-html.pipe';
+import { DisplayNullPipe } from './pipes/display-null.pipe';
+import { FormatNumberInput } from './pipes/format-number-input.pipe';
+import { LocalDatePipe } from './pipes/local-date.pipe';
+import { MyNumberPipe } from './pipes/my-number.pipe';
+import { TrimStringPipe } from './pipes/trim-string.pipe';
+import { ThemeEventsService } from './theme/theme-event.service';
+import { SessionStorageService } from './services/storage/session-storage.service';
+import { MatCardModule } from '@angular/material/card';
+import { PermissionsService } from './permissions/permissions.service';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { ArrayService } from './array.service';
+import { OverlayComponent } from './component/overlay/overlay.component';
+import { HeaderComponent } from './component/header/header.component';
+import { SubHeaderComponent } from './component/sub-header/sub-header.component';
+import { MyDialogPopupLoginComponent } from './component/popup/popup-login/popup-login.component';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { NgxPermissionsModule } from 'ngx-permissions';
+import { RouterModule } from '@angular/router';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatButtonModule } from '@angular/material/button';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { AesService } from './services/jwt-security/aes.service';
+import { CookieService } from 'ngx-cookie-service';
+import { ToasterEventsService } from "./toaster/toaster-events.service";
+import { HeaderEventsService } from "./event/header/header-events.service";
+import { MatInputModule } from '@angular/material/input';
+import { CommonTranslatePipe } from "./pipes/common-translate.pipe";
+import { HistoryService } from "./services/history/history.service";
+import { LangService } from "./services/translate-language/lang.service";
+import { MatAutocompleteModule } from "@angular/material/autocomplete";
+import { ElasticsearchService } from "./services/elasticsearch/elasticsearch.service";
+import { ShowIfTruncatedDirective } from './directives/show-if-truncated.directive';
+import { ThirdPartyAddressPipe } from "./pipes/third-party-address.pipe";
+import { FormatDurationPipe } from "./pipes/format-duration.pipe";
+import { FormatCurrencyPipe } from './pipes/format-currency.pipe';
+import { CustomMatPaginatorIntl } from "./paginator/custom-paginator-configuration";
+import { ThirdPartyAddressSearchPipe } from "./pipes/third-party-address-search.pipe";
+import { VideoApiService } from "./services/api/video-api.service";
+import { CommercialApiService } from "./services/api/commercial-api.service";
+import { MenuComponent } from './component/header/menu/menu.component';
+import { AuthService } from './services/auth/auth.service';
+import { LegalApiService } from "./services/api/legal-api.service";
+import { UserSubsidiaryService } from './services/user/user-subsidiary.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/translate-language/lang.service";
+export class UtilModule {
+    constructor(langService) {
+        this.langService = langService;
+        this.langService.translateLanguage();
+    }
+    static forRoot(config = DEFAULT_WEB_CONFIG) {
+        return {
+            ngModule: UtilModule,
+            providers: [{ provide: WEB_CONFIG, useValue: config }]
+        };
+    }
+    static forChild(config = DEFAULT_WEB_CONFIG) {
+        return {
+            ngModule: UtilModule,
+            providers: [{ provide: WEB_CONFIG, useValue: config }]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UtilModule, deps: [{ token: i1.LangService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: UtilModule, declarations: [MyNumberFormatterDirective,
+            CapitalizefirstPipe,
+            SpacesNumberPipe,
+            SanitizeHtml,
+            DisplayNullPipe,
+            FormatNumberInput,
+            LocalDatePipe,
+            MyNumberPipe,
+            TrimStringPipe,
+            CommonTranslatePipe,
+            ThirdPartyAddressPipe,
+            ThirdPartyAddressSearchPipe,
+            FormatDurationPipe,
+            MyDialogPopupLoginComponent,
+            OverlayComponent,
+            HeaderComponent,
+            SubHeaderComponent,
+            ShowIfTruncatedDirective,
+            FormatCurrencyPipe,
+            MenuComponent], imports: [MatInputModule,
+            MatTooltipModule,
+            MatButtonModule,
+            MatToolbarModule,
+            MatFormFieldModule,
+            CommonModule,
+            TranslateModule,
+            MatCardModule,
+            MatDialogModule,
+            NgxPermissionsModule,
+            MatProgressSpinnerModule,
+            RouterModule,
+            ReactiveFormsModule,
+            FormsModule,
+            MatIconModule,
+            MatMenuModule,
+            MatAutocompleteModule], exports: [MyNumberFormatterDirective,
+            CapitalizefirstPipe,
+            SpacesNumberPipe,
+            SanitizeHtml,
+            DisplayNullPipe,
+            FormatNumberInput,
+            LocalDatePipe,
+            MyNumberPipe,
+            FormatCurrencyPipe,
+            FormatDurationPipe,
+            TrimStringPipe,
+            ThirdPartyAddressPipe,
+            HeaderComponent,
+            OverlayComponent,
+            SubHeaderComponent,
+            ShowIfTruncatedDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UtilModule, providers: [
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: InterceptorHttpService,
+                multi: true
+            },
+            TranslateService,
+            ThemeEventsService,
+            SessionStorageService,
+            LocalStorageService,
+            PermissionsService,
+            ArrayService,
+            CustomMatPaginatorIntl,
+            CommonApiService,
+            DatePipe,
+            ThirdPartyAddressSearchPipe,
+            LocalDatePipe,
+            MyNumberPipe,
+            AesService,
+            CookieService,
+            ToasterEventsService,
+            HeaderEventsService,
+            HistoryService,
+            LangService,
+            ElasticsearchService,
+            LegalApiService,
+            CurrencyPipe,
+            MatTooltipModule,
+            CommercialApiService,
+            VideoApiService,
+            AuthService,
+            UserSubsidiaryService
+        ], imports: [MatInputModule,
+            MatTooltipModule,
+            MatButtonModule,
+            MatToolbarModule,
+            MatFormFieldModule,
+            CommonModule,
+            TranslateModule,
+            MatCardModule,
+            MatDialogModule,
+            NgxPermissionsModule,
+            MatProgressSpinnerModule,
+            RouterModule,
+            ReactiveFormsModule,
+            FormsModule,
+            MatIconModule,
+            MatMenuModule,
+            MatAutocompleteModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UtilModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        MatInputModule,
+                        MatTooltipModule,
+                        MatButtonModule,
+                        MatToolbarModule,
+                        MatFormFieldModule,
+                        CommonModule,
+                        TranslateModule,
+                        MatCardModule,
+                        MatDialogModule,
+                        NgxPermissionsModule,
+                        MatProgressSpinnerModule,
+                        RouterModule,
+                        ReactiveFormsModule,
+                        FormsModule,
+                        MatIconModule,
+                        MatMenuModule,
+                        MatAutocompleteModule,
+                    ],
+                    declarations: [
+                        MyNumberFormatterDirective,
+                        CapitalizefirstPipe,
+                        SpacesNumberPipe,
+                        SanitizeHtml,
+                        DisplayNullPipe,
+                        FormatNumberInput,
+                        LocalDatePipe,
+                        MyNumberPipe,
+                        TrimStringPipe,
+                        CommonTranslatePipe,
+                        ThirdPartyAddressPipe,
+                        ThirdPartyAddressSearchPipe,
+                        FormatDurationPipe,
+                        MyDialogPopupLoginComponent,
+                        OverlayComponent,
+                        HeaderComponent,
+                        SubHeaderComponent,
+                        ShowIfTruncatedDirective,
+                        FormatCurrencyPipe,
+                        MenuComponent
+                    ],
+                    providers: [
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: InterceptorHttpService,
+                            multi: true
+                        },
+                        TranslateService,
+                        ThemeEventsService,
+                        SessionStorageService,
+                        LocalStorageService,
+                        PermissionsService,
+                        ArrayService,
+                        CustomMatPaginatorIntl,
+                        CommonApiService,
+                        DatePipe,
+                        ThirdPartyAddressSearchPipe,
+                        LocalDatePipe,
+                        MyNumberPipe,
+                        AesService,
+                        CookieService,
+                        ToasterEventsService,
+                        HeaderEventsService,
+                        HistoryService,
+                        LangService,
+                        ElasticsearchService,
+                        LegalApiService,
+                        CurrencyPipe,
+                        MatTooltipModule,
+                        CommercialApiService,
+                        VideoApiService,
+                        AuthService,
+                        UserSubsidiaryService
+                    ],
+                    exports: [
+                        MyNumberFormatterDirective,
+                        CapitalizefirstPipe,
+                        SpacesNumberPipe,
+                        SanitizeHtml,
+                        DisplayNullPipe,
+                        FormatNumberInput,
+                        LocalDatePipe,
+                        MyNumberPipe,
+                        FormatCurrencyPipe,
+                        FormatDurationPipe,
+                        TrimStringPipe,
+                        ThirdPartyAddressPipe,
+                        HeaderComponent,
+                        OverlayComponent,
+                        SubHeaderComponent,
+                        ShowIfTruncatedDirective
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LangService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.module.js","sourceRoot":"","sources":["../../../../../projects/new-front-common-library/src/lib/util/util.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Config, DEFAULT_WEB_CONFIG, WEB_CONFIG } from './config';\n// Angular\nimport { ModuleWithProviders, NgModule } from '@angular/core';\nimport { TranslateModule, TranslateService } from '@ngx-translate/core';\nimport { HTTP_INTERCEPTORS } from '@angular/common/http';\nimport {CommonModule, CurrencyPipe, DatePipe} from '@angular/common';\n// Services\nimport { CommonApiService } from './services/api/common-api.service';\n// Modules\nimport { LocalStorageService } from './services/storage/local-storage.service';\nimport { InterceptorHttpService } from './services/jwt-security/interceptorhttp.service';\nimport { MyNumberFormatterDirective } from './directives/my-number-formatter-directive';\nimport { CapitalizefirstPipe } from './pipes/capitalizefirst.pipe';\nimport { SpacesNumberPipe } from './pipes/comma-separated-number.pipe';\nimport { SanitizeHtml } from './pipes/display-html.pipe';\nimport { DisplayNullPipe } from './pipes/display-null.pipe';\nimport { FormatNumberInput } from './pipes/format-number-input.pipe';\nimport { LocalDatePipe } from './pipes/local-date.pipe';\nimport { MyNumberPipe } from './pipes/my-number.pipe';\nimport { TrimStringPipe } from './pipes/trim-string.pipe';\nimport { ThemeEventsService } from './theme/theme-event.service';\nimport { SessionStorageService } from './services/storage/session-storage.service';\nimport { MatCardModule } from '@angular/material/card';\nimport { PermissionsService } from './permissions/permissions.service';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport { ArrayService } from './array.service';\nimport { OverlayComponent } from './component/overlay/overlay.component';\nimport { HeaderComponent } from './component/header/header.component';\nimport { SubHeaderComponent } from './component/sub-header/sub-header.component';\nimport { MyDialogPopupLoginComponent } from './component/popup/popup-login/popup-login.component';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { NgxPermissionsModule } from 'ngx-permissions';\nimport { RouterModule } from '@angular/router';\nimport { MatDialogModule } from '@angular/material/dialog';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatToolbarModule } from '@angular/material/toolbar';\nimport { MatDividerModule } from '@angular/material/divider';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { MatTableModule } from '@angular/material/table';\nimport { AesService } from './services/jwt-security/aes.service';\nimport { CookieService } from 'ngx-cookie-service';\nimport { ToasterEventsService } from \"./toaster/toaster-events.service\";\nimport { HeaderEventsService } from \"./event/header/header-events.service\";\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatInputModule } from '@angular/material/input';\nimport { CommonTranslatePipe } from \"./pipes/common-translate.pipe\";\nimport { HistoryService } from \"./services/history/history.service\";\nimport { LangService } from \"./services/translate-language/lang.service\";\nimport { MatAutocompleteModule } from \"@angular/material/autocomplete\";\nimport { ElasticsearchService } from \"./services/elasticsearch/elasticsearch.service\";\nimport { ShowIfTruncatedDirective } from './directives/show-if-truncated.directive';\nimport { NgSelectModule } from \"@ng-select/ng-select\";\nimport { ThirdPartyAddressPipe } from \"./pipes/third-party-address.pipe\";\nimport { FormatDurationPipe } from \"./pipes/format-duration.pipe\";\nimport { FormatCurrencyPipe } from './pipes/format-currency.pipe';\nimport { CustomMatPaginatorIntl } from \"./paginator/custom-paginator-configuration\";\nimport {ThirdPartyAddressSearchPipe} from \"./pipes/third-party-address-search.pipe\";\nimport {VideoApiService} from \"./services/api/video-api.service\";\nimport {CommercialApiService} from \"./services/api/commercial-api.service\";\nimport { MenuComponent } from './component/header/menu/menu.component';\nimport { AuthService } from './services/auth/auth.service';\nimport {LegalApiService} from \"./services/api/legal-api.service\";\nimport { UserSubsidiaryService } from './services/user/user-subsidiary.service';\n\n\n@NgModule({\n  imports: [\n    MatInputModule,\n    MatTooltipModule,\n    MatButtonModule,\n    MatToolbarModule,\n    MatFormFieldModule,\n    CommonModule,\n    TranslateModule,\n    MatCardModule,\n    MatDialogModule,\n    NgxPermissionsModule,\n    MatProgressSpinnerModule,\n    RouterModule,\n    ReactiveFormsModule,\n    FormsModule,\n    MatIconModule,\n    MatMenuModule,\n    MatAutocompleteModule,\n  ],\n  declarations: [\n    MyNumberFormatterDirective,\n    CapitalizefirstPipe,\n    SpacesNumberPipe,\n    SanitizeHtml,\n    DisplayNullPipe,\n    FormatNumberInput,\n    LocalDatePipe,\n    MyNumberPipe,\n    TrimStringPipe,\n    CommonTranslatePipe,\n    ThirdPartyAddressPipe,\n    ThirdPartyAddressSearchPipe,\n    FormatDurationPipe,\n    MyDialogPopupLoginComponent,\n    OverlayComponent,\n    HeaderComponent,\n    SubHeaderComponent,\n    ShowIfTruncatedDirective,\n    FormatCurrencyPipe,\n    MenuComponent\n  ],\n  providers: [\n    {\n      provide: HTTP_INTERCEPTORS,\n      useClass: InterceptorHttpService,\n      multi: true\n    },\n    TranslateService,\n    ThemeEventsService,\n    SessionStorageService,\n    LocalStorageService,\n    PermissionsService,\n    ArrayService,\n    CustomMatPaginatorIntl,\n    CommonApiService,\n    DatePipe,\n    ThirdPartyAddressSearchPipe,\n    LocalDatePipe,\n    MyNumberPipe,\n    AesService,\n    CookieService,\n    ToasterEventsService,\n    HeaderEventsService,\n    HistoryService,\n    LangService,\n    ElasticsearchService,\n    LegalApiService,\n    CurrencyPipe,\n    MatTooltipModule,\n    CommercialApiService,\n    VideoApiService,\n    AuthService,\n    UserSubsidiaryService\n  ],\n  exports: [\n    MyNumberFormatterDirective,\n    CapitalizefirstPipe,\n    SpacesNumberPipe,\n    SanitizeHtml,\n    DisplayNullPipe,\n    FormatNumberInput,\n    LocalDatePipe,\n    MyNumberPipe,\n    FormatCurrencyPipe,\n    FormatDurationPipe,\n    TrimStringPipe,\n    ThirdPartyAddressPipe,\n    HeaderComponent,\n    OverlayComponent,\n    SubHeaderComponent,\n    ShowIfTruncatedDirective\n  ]\n})\nexport class UtilModule {\n  constructor(private readonly langService: LangService) {\n    this.langService.translateLanguage();\n  }\n\n  public static forRoot(\n    config: Config = DEFAULT_WEB_CONFIG\n  ): ModuleWithProviders<UtilModule> {\n    return {\n      ngModule: UtilModule,\n      providers: [{provide: WEB_CONFIG, useValue: config}]\n    };\n  }\n\n  public static forChild(\n    config: Config = DEFAULT_WEB_CONFIG\n  ): ModuleWithProviders<UtilModule> {\n    return {\n      ngModule: UtilModule,\n      providers: [{provide: WEB_CONFIG, useValue: config}]\n    };\n  }\n}\n"]}

package/esm2022/new-front-common-library.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV3LWZyb250LWNvbW1vbi1saWJyYXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbmV3LWZyb250LWNvbW1vbi1saWJyYXJ5L3NyYy9uZXctZnJvbnQtY29tbW9uLWxpYnJhcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,59 @@
+/*
+ * Public API Surface of front-common-library-3
+ */
+export * from './lib/util/util.module';
+export * from './lib/util/array.service';
+export { User } from './lib/util/decorators/user.decorator';
+export { Theme } from './lib/util/decorators/theme.decorator';
+export { CustomMatPaginatorIntl } from './lib/util/paginator/custom-paginator-configuration';
+export * from './lib/util/services/storage/local-storage.service';
+export * from './lib/util/services/storage/session-storage.service';
+export * from './lib/util/event/storage/local-storage-events.service';
+export * from './lib/util/event/storage/session-storage-events.service';
+export * from './lib/util/config';
+export * from './lib/util/theme/theme-event.service';
+export * from './lib/util/regex/regex.service';
+export * from './lib/util/permissions/permissions.service';
+export * from './lib/util/date/date.util';
+export * from './lib/util/date/date-format-constants';
+export * from './lib/util/sort';
+export * from './lib/util/number.validator';
+export * from './lib/util/services/jwt-security/aes.service';
+export * from './lib/util/component/overlay/overlay.service';
+export * from './lib/util/component/overlay/overlay.component';
+export * from './lib/util/component/header/header.component';
+export * from './lib/util/component/sub-header/sub-header.component';
+export * from './lib/util/component/popup/popup-login/popup-login.component';
+export * from './lib/util/services/jwt-security/jwt.helpher';
+export * from './lib/util/models';
+export * from './lib/util/services/guard/auth.guard';
+export * from './lib/util/services/guard/login.guard';
+export * from './lib/util/services/form-action/form-actions-events.service';
+export * from './lib/util/services/api/common-api.service';
+export * from './lib/util/services/history/history.service';
+export * from './lib/util/services/translate-language/lang.service';
+export * from './lib/util/services/elasticsearch/elasticsearch.service';
+export * from './lib/util/services/auth/auth.service';
+export * from './lib/util/services/user/user-subsidiary.service';
+export * from './lib/util/http/http-params.builder';
+export * from './lib/util/date/PeriodModel';
+export * from './lib/util/pipes/capitalizefirst.pipe';
+export * from './lib/util/services/interceptor/auth.interceptor';
+export * from './lib/util/pipes/local-date.pipe';
+export * from './lib/util/pipes/trim-string.pipe';
+export * from './lib/util/pipes/common-translate.pipe';
+export * from './lib/util/pipes/my-number.pipe';
+export * from './lib/util/pipes/comma-separated-number.pipe';
+export * from './lib/util/pipes/display-html.pipe';
+export * from './lib/util/pipes/display-null.pipe';
+export * from './lib/util/pipes/format-number-input.pipe';
+export * from './lib/util/directives/my-number-formatter-directive';
+export * from './lib/util/pipes/third-party-address.pipe';
+export * from './lib/util/pipes/format-duration.pipe';
+export * from './lib/util/pipes/format-currency.pipe';
+export * from './lib/util/enums/status-color.enum';
+export * from './lib/util/toaster/toaster-events.service';
+export * from './lib/util/event/header/header-events.service';
+export * from './lib/util/directives/show-if-truncated.directive';
+export * from './lib/util/i18n/multi-translate-http-loader';
+//# sourceMappingURL=data:application/json;base64,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