@osovitny/anatoly 2.1.14 → 2.14.2

package/esm2020/lib/core/interceptors/httpInterceptor.mjs

@@ -0,0 +1,108 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny
+    Anatoly Osovitny
+
+  Created:
+    25 March 2020
+
+  Version:
+    1.0
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+// Node
+import { HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+// RxJS
+import { tap } from 'rxjs/operators';
+// App
+import { AppCoreSettings } from '../consts/settings';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/loading.service";
+import * as i2 from "../logging/logging.service";
+export class AnatolyHttpInterceptor {
+    constructor(loadingService, loggingService) {
+        this.loadingService = loadingService;
+        this.loggingService = loggingService;
+        this.longRunningExceptionsList = [];
+        this.autoCDNSASTokenUrls = ['chunks', 'resources'];
+        this.externalSiteUrls = ['azurewebsites.net'];
+    }
+    intercept(req, next) {
+        const isCDNEnabled = AppCoreSettings.IsCDNEnabled;
+        const cdnSasToken = AppCoreSettings.CDNSASToken;
+        const isLoadingFreezed = this.loadingService.isFreezed;
+        const authorizationTokenRequired = true;
+        const url = req.url.toLowerCase();
+        const originalUrl = req.url;
+        let isExternalSite = false;
+        let loadingRequired = !isLoadingFreezed;
+        if (!isLoadingFreezed) {
+            for (const i of this.longRunningExceptionsList) {
+                if (url.indexOf(this.longRunningExceptionsList[i]) >= 0) {
+                    loadingRequired = false;
+                    break;
+                }
+            }
+        }
+        if (isCDNEnabled) {
+            for (const i of this.autoCDNSASTokenUrls) {
+                if (url.indexOf(this.autoCDNSASTokenUrls[i]) >= 0) {
+                    req = req.clone({ url: originalUrl + cdnSasToken });
+                    break;
+                }
+            }
+        }
+        for (const i of this.externalSiteUrls) {
+            if (url.indexOf(this.externalSiteUrls[i]) >= 0) {
+                isExternalSite = true;
+                break;
+            }
+        }
+        // VadimOS: IE11-fix
+        if (url.indexOf('/api/') > -1) {
+            let newUrl = '';
+            const t = new Date().getTime().toString();
+            if (url.indexOf('?') > -1) {
+                newUrl = originalUrl + '&t=' + t;
+            }
+            else {
+                newUrl = originalUrl + '?t=' + t;
+            }
+            req = req.clone({ url: newUrl });
+        }
+        req = req.clone({ headers: req.headers.set('Accept', 'application/json') });
+        req = req.clone({ headers: req.headers.set('Accept', 'application/text') });
+        this.onRequestStart(loadingRequired);
+        return next.handle(req).pipe(tap((event) => {
+            if (event instanceof HttpResponse) {
+                this.onRequestEnd(loadingRequired);
+            }
+        }, (err) => {
+            this.onRequestEnd(loadingRequired);
+            this.loggingService.logError(err);
+        }));
+    }
+    onRequestStart(loadingRequired) {
+        if (loadingRequired) {
+            this.loadingService.show();
+        }
+    }
+    onRequestEnd(loadingRequired) {
+        if (loadingRequired) {
+            this.loadingService.hide();
+        }
+    }
+}
+AnatolyHttpInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AnatolyHttpInterceptor, deps: [{ token: i1.LoadingService }, { token: i2.LoggingService }], target: i0.ɵɵFactoryTarget.Injectable });
+AnatolyHttpInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AnatolyHttpInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: AnatolyHttpInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LoadingService }, { type: i2.LoggingService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"httpInterceptor.js","sourceRoot":"","sources":["../../../../../../projects/anatoly/src/lib/core/interceptors/httpInterceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n<file>\r\n  Project:\r\n    @osovitny/anatoly\r\n\r\n  Authors:\r\n    Vadim Osovitny\r\n    Anatoly Osovitny\r\n\r\n  Created:\r\n    25 March 2020\r\n\r\n  Version:\r\n    1.0\r\n\r\n  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.\r\n</file>\r\n*/\r\n\r\n// Node\r\nimport {HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse} from '@angular/common/http';\r\nimport {Injectable} from '@angular/core';\r\n\r\n// RxJS\r\nimport {tap} from 'rxjs/operators';\r\nimport {Observable} from 'rxjs';\r\n\r\n// App\r\nimport {AppCoreSettings} from '../consts/settings';\r\nimport {LoadingService} from '../services/loading.service';\r\nimport {LoggingService} from '../logging/logging.service';\r\n\r\n@Injectable()\r\nexport class AnatolyHttpInterceptor implements HttpInterceptor {\r\n  protected longRunningExceptionsList = [];\r\n  protected autoCDNSASTokenUrls = ['chunks', 'resources'];\r\n  protected externalSiteUrls = ['azurewebsites.net'];\r\n\r\n  constructor(protected loadingService: LoadingService, protected loggingService: LoggingService) {\r\n  }\r\n\r\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n    const isCDNEnabled = AppCoreSettings.IsCDNEnabled;\r\n    const cdnSasToken = AppCoreSettings.CDNSASToken;\r\n\r\n    const isLoadingFreezed = this.loadingService.isFreezed;   \r\n    const authorizationTokenRequired = true;\r\n    const url = req.url.toLowerCase();\r\n    const originalUrl = req.url;\r\n    let isExternalSite = false;\r\n    let loadingRequired = !isLoadingFreezed;\r\n\r\n    if (!isLoadingFreezed) {\r\n      for (const i of this.longRunningExceptionsList) {\r\n        if (url.indexOf(this.longRunningExceptionsList[i]) >= 0) {\r\n          loadingRequired = false;\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (isCDNEnabled) {\r\n      for (const i of this.autoCDNSASTokenUrls) {\r\n        if (url.indexOf(this.autoCDNSASTokenUrls[i]) >= 0) {\r\n          req = req.clone({ url: originalUrl + cdnSasToken });\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    for (const i of this.externalSiteUrls) {\r\n      if (url.indexOf(this.externalSiteUrls[i]) >= 0) {\r\n        isExternalSite = true;\r\n        break;\r\n      }\r\n    }\r\n\r\n    // VadimOS: IE11-fix\r\n    if (url.indexOf('/api/') > -1) {\r\n      let newUrl = '';\r\n      const t = new Date().getTime().toString();\r\n\r\n      if (url.indexOf('?') > -1) {\r\n        newUrl = originalUrl + '&t=' + t;\r\n      } else {\r\n        newUrl = originalUrl + '?t=' + t;\r\n      }\r\n\r\n      req = req.clone({ url: newUrl });\r\n    }\r\n\r\n    req = req.clone({ headers: req.headers.set('Accept', 'application/json') });\r\n    req = req.clone({ headers: req.headers.set('Accept', 'application/text') });\r\n\r\n    this.onRequestStart(loadingRequired);\r\n\r\n    return next.handle(req).pipe(\r\n      tap(\r\n        (event: HttpEvent<any>) => {\r\n          if (event instanceof HttpResponse) {\r\n            this.onRequestEnd(loadingRequired);\r\n          }\r\n        },\r\n        (err: any) => {\r\n          this.onRequestEnd(loadingRequired);\r\n          this.loggingService.logError(err);\r\n        }\r\n      )\r\n    );\r\n  }\r\n\r\n  onRequestStart(loadingRequired: boolean) {\r\n    if (loadingRequired) {\r\n      this.loadingService.show();\r\n    }\r\n  }\r\n\r\n  onRequestEnd(loadingRequired: boolean) {\r\n    if (loadingRequired) {\r\n      this.loadingService.hide();\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/core/localization/localization.module.mjs

@@ -0,0 +1,47 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny
+    Anatoly Osovitny
+
+  Created:
+     12 May 2020
+
+  Version:
+    1.0
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+// Node
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+// Pipes
+import { LocalizePipe } from './localize.pipe';
+import * as i0 from "@angular/core";
+export class LocalizationModule {
+}
+LocalizationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LocalizationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.6", ngImport: i0, type: LocalizationModule, declarations: [LocalizePipe], imports: [TranslateModule], exports: [TranslateModule,
+        LocalizePipe] });
+LocalizationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationModule, imports: [TranslateModule, TranslateModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        TranslateModule
+                    ],
+                    exports: [
+                        TranslateModule,
+                        LocalizePipe
+                    ],
+                    declarations: [
+                        LocalizePipe
+                    ],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemF0aW9uLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuYXRvbHkvc3JjL2xpYi9jb3JlL2xvY2FsaXphdGlvbi9sb2NhbGl6YXRpb24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7OztFQWlCRTtBQUVGLE9BQU87QUFDUCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV0RCxRQUFRO0FBQ1IsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQWdCL0MsTUFBTSxPQUFPLGtCQUFrQjs7K0dBQWxCLGtCQUFrQjtnSEFBbEIsa0JBQWtCLGlCQUwzQixZQUFZLGFBUFosZUFBZSxhQUdmLGVBQWU7UUFDZixZQUFZO2dIQVFILGtCQUFrQixZQVozQixlQUFlLEVBR2YsZUFBZTsyRkFTTixrQkFBa0I7a0JBZDlCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLGVBQWU7cUJBQ2hCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxlQUFlO3dCQUNmLFlBQVk7cUJBQ2I7b0JBQ0QsWUFBWSxFQUFFO3dCQUNaLFlBQVk7cUJBQ2I7b0JBQ0QsU0FBUyxFQUFFLEVBQ1Y7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG48ZmlsZT5cclxuICBQcm9qZWN0OlxyXG4gICAgQG9zb3ZpdG55L2FuYXRvbHlcclxuXHJcbiAgQXV0aG9yczpcclxuICAgIFZhZGltIE9zb3ZpdG55XHJcbiAgICBBbmF0b2x5IE9zb3ZpdG55XHJcblxyXG4gIENyZWF0ZWQ6XHJcbiAgICAgMTIgTWF5IDIwMjBcclxuXHJcbiAgVmVyc2lvbjpcclxuICAgIDEuMFxyXG5cclxuICBDb3B5cmlnaHQgKGMpIDIwMTYtMjAyMiBPc292aXRueSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXHJcbjwvZmlsZT5cclxuKi9cclxuXHJcbi8vIE5vZGVcclxuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgVHJhbnNsYXRlTW9kdWxlIH0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSc7XHJcblxyXG4vLyBQaXBlc1xyXG5pbXBvcnQgeyBMb2NhbGl6ZVBpcGUgfSBmcm9tICcuL2xvY2FsaXplLnBpcGUnO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBpbXBvcnRzOiBbXHJcbiAgICBUcmFuc2xhdGVNb2R1bGVcclxuICBdLFxyXG4gIGV4cG9ydHM6IFtcclxuICAgIFRyYW5zbGF0ZU1vZHVsZSxcclxuICAgIExvY2FsaXplUGlwZVxyXG4gIF0sXHJcbiAgZGVjbGFyYXRpb25zOiBbXHJcbiAgICBMb2NhbGl6ZVBpcGVcclxuICBdLFxyXG4gIHByb3ZpZGVyczogW1xyXG4gIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIExvY2FsaXphdGlvbk1vZHVsZSB7XHJcbn1cclxuIl19

package/esm2020/lib/core/localization/localization.service.mjs

@@ -0,0 +1,185 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny
+    Anatoly Osovitny
+
+  Created:
+    05 May 2020
+
+  Version:
+    1.0
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+//Node
+import { Injectable } from '@angular/core';
+//Date fns
+import { format, isValid, formatDistanceToNow, formatDistance } from 'date-fns';
+import { utcToZonedTime } from 'date-fns-tz';
+// VadimOS: IE11-fix. DON'T change next imports!
+// Reason: https://github.com/date-fns/date-fns/issues/666
+import enUS from 'date-fns/locale/en-US';
+import { Convert } from '../convert';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class LocalizationService {
+    constructor(translate) {
+        this.translate = translate;
+        this.setSupportedLanguages(['en']);
+    }
+    format(str, args) {
+        return str.replace(/{(\d+)}/g, function (match, number) {
+            return typeof args[number] != 'undefined'
+                ? args[number]
+                : match;
+        });
+    }
+    ;
+    configureTranslationSettings(translate) {
+        const languageToSet = 'en';
+        this.dateFnsLocale = { locale: enUS };
+        translate.setDefaultLang(languageToSet);
+        return languageToSet;
+    }
+    getBrowserLanguage() {
+        return this.translate.getBrowserLang();
+    }
+    getDatefnsLocale() {
+        let dfnLocale;
+        switch (this.getBrowserLanguage()) {
+            case 'en':
+                dfnLocale = { locale: enUS };
+                break;
+            default:
+                dfnLocale = { locale: enUS };
+        }
+        return dfnLocale;
+    }
+    setDefaultLanguage(lang) {
+        this.translate.setDefaultLang(lang);
+    }
+    setSupportedLanguages(languages) {
+        this.translate.addLangs(languages);
+    }
+    updateLanguage(language) {
+        this.translate.use(language);
+    }
+    getLocalizedValue(key, params) {
+        const value = this.translate.instant(key);
+        if (!params || params.length === 0) {
+            return value;
+        }
+        return this.format(value, params);
+    }
+    getLocalizedDate(key) {
+        if (isValid(new Date(key))) {
+            return format(new Date(key), 'dd.MM.yyyy', this.dateFnsLocale);
+        }
+        return "Invalid Date";
+    }
+    getLocalizedDateTime(key) {
+        let dateValue = new Date(key);
+        if (isValid(dateValue)) {
+            let localDate = Convert.toLocalizedDateTime(dateValue);
+            return format(localDate, 'dd.MM.yyyy HH:mm', this.dateFnsLocale);
+        }
+        return "Invalid Date";
+    }
+    getLocalizedDistanceInWords(endedDate, startedDate) {
+        if (isValid(new Date(endedDate)) && isValid(new Date(startedDate))) {
+            return formatDistance(new Date(endedDate), new Date(startedDate), this.dateFnsLocale);
+        }
+        return "Invalid Date";
+    }
+    getLocalizedDistanceToNowInWords(date) {
+        if (isValid(new Date(date))) {
+            return formatDistanceToNow(new Date(date), this.dateFnsLocale);
+        }
+        return "Invalid Date";
+    }
+    //UTC Operations --------------------------------------------------------------
+    getUTCToLocalizedDate(key) {
+        let browserTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (key) {
+            if (key.indexOf("T") == -1) {
+                key = key.replace(" ", "T");
+            }
+            if (key.indexOf("Z") == -1) {
+                key = key + "Z";
+            }
+        }
+        if (browserTimeZone) {
+            let localDateTime = utcToZonedTime(key, browserTimeZone);
+            return format(localDateTime, 'dd.MM.yyyy', this.dateFnsLocale);
+        }
+        else {
+            return format(new Date(key), 'dd.MM.yyyy', this.dateFnsLocale);
+        }
+    }
+    getUTCToLocalizedDateTime(key) {
+        let browserTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (key) {
+            if (key.indexOf("T") == -1) {
+                key = key.replace(" ", "T");
+            }
+            if (key.indexOf("Z") == -1) {
+                key = key + "Z";
+            }
+        }
+        if (browserTimeZone) {
+            let localDateTime = utcToZonedTime(key, browserTimeZone);
+            return format(localDateTime, 'dd.MM.yyyy HH:mm', this.dateFnsLocale);
+        }
+        else {
+            return format(new Date(key), 'dd.MM.yyyy HH:mm', this.dateFnsLocale);
+        }
+    }
+    //https://date-fns.org/v1.30.1/docs/distanceInWords
+    getUTCToLocalizedDistanceToNowInWords(date) {
+        date = this.safeUtcToZonedTime(date);
+        if (isValid(new Date(date))) {
+            return formatDistanceToNow(new Date(date), this.dateFnsLocale);
+        }
+        return "Invalid Date";
+    }
+    safeUtcToZonedTime(date) {
+        let result = date;
+        try {
+            if (date) {
+                if (date.indexOf("T") == -1) {
+                    date = date.replace(" ", "T");
+                }
+                if (date.indexOf("Z") == -1) {
+                    date = date + "Z";
+                }
+            }
+            let browserTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            if (browserTimeZone) {
+                result = utcToZonedTime(date, browserTimeZone).toString();
+            }
+            else {
+                result = new Date(date).toString();
+            }
+        }
+        catch {
+            if (date) {
+                console.log("UTC to Local conversion failed for :" + date.toString());
+            }
+        }
+        return result;
+    }
+}
+LocalizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+LocalizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.service.js","sourceRoot":"","sources":["../../../../../../projects/anatoly/src/lib/core/localization/localization.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n<file>\r\n  Project:\r\n    @osovitny/anatoly\r\n\r\n  Authors:\r\n    Vadim Osovitny\r\n    Anatoly Osovitny\r\n\r\n  Created:\r\n    05 May 2020\r\n\r\n  Version:\r\n    1.0\r\n\r\n  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.\r\n</file>\r\n*/\r\n\r\n//Node\r\nimport { Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\n\r\n//Date fns\r\nimport { format, isValid, formatDistanceToNow, formatDistance } from 'date-fns';\r\nimport { utcToZonedTime } from 'date-fns-tz';\r\n\r\n// VadimOS: IE11-fix. DON'T change next imports!\r\n// Reason: https://github.com/date-fns/date-fns/issues/666\r\nimport enUS from 'date-fns/locale/en-US';\r\n\r\n// App\r\nimport {AppCoreSettings} from '../consts/settings';\r\nimport {Convert} from '../convert';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LocalizationService {\r\n  dateFnsLocale: any;\r\n\r\n  constructor(private translate: TranslateService) {\r\n    this.setSupportedLanguages(['en']);\r\n  }\r\n\r\n  private format(str: string, args) {\r\n    return str.replace(/{(\\d+)}/g, function (match, number) {\r\n      return typeof args[number] != 'undefined'\r\n        ? args[number]\r\n        : match\r\n        ;\r\n    });\r\n  };\r\n\r\n  configureTranslationSettings(translate: TranslateService): string {\r\n    const languageToSet = 'en';\r\n    this.dateFnsLocale = { locale: enUS };\r\n\r\n    translate.setDefaultLang(languageToSet);\r\n    return languageToSet;\r\n  }\r\n\r\n  getBrowserLanguage(): string {\r\n    return this.translate.getBrowserLang();\r\n  }\r\n\r\n  getDatefnsLocale(): any {\r\n    let dfnLocale: any;\r\n\r\n    switch (this.getBrowserLanguage()) {\r\n      case 'en':\r\n        dfnLocale = { locale: enUS };\r\n        break;\r\n\r\n      default:\r\n        dfnLocale = { locale: enUS };\r\n    }\r\n\r\n    return dfnLocale;\r\n  }\r\n\r\n  setDefaultLanguage(lang: string): void {\r\n    this.translate.setDefaultLang(lang);\r\n  }\r\n\r\n  setSupportedLanguages(languages: string[]): void {\r\n    this.translate.addLangs(languages);\r\n  }\r\n\r\n  updateLanguage(language: string): void {\r\n    this.translate.use(language);\r\n  }\r\n\r\n  getLocalizedValue(key: string, params?: any[]): string {\r\n    const value = this.translate.instant(key);\r\n\r\n    if (!params || params.length === 0) {\r\n      return value;\r\n    }\r\n\r\n    return this.format(value, params);\r\n  }\r\n\r\n  getLocalizedDate(key: string): string {\r\n    if (isValid(new Date(key))) {\r\n      return format(new Date(key), 'dd.MM.yyyy', this.dateFnsLocale);\r\n    }\r\n\r\n    return \"Invalid Date\";\r\n  }\r\n\r\n  getLocalizedDateTime(key: string) {\r\n    let dateValue = new Date(key);\r\n    if (isValid(dateValue)) {\r\n      let localDate = Convert.toLocalizedDateTime(dateValue);\r\n      return format(localDate, 'dd.MM.yyyy HH:mm', this.dateFnsLocale);\r\n    }\r\n\r\n    return \"Invalid Date\";\r\n  }\r\n\r\n  getLocalizedDistanceInWords(endedDate: string, startedDate: string): string {\r\n    if (isValid(new Date(endedDate)) && isValid(new Date(startedDate))) {\r\n      return formatDistance(new Date(endedDate), new Date(startedDate), this.dateFnsLocale);\r\n    }\r\n\r\n    return \"Invalid Date\";\r\n  }\r\n\r\n  getLocalizedDistanceToNowInWords(date: string): string {\r\n    if (isValid(new Date(date))) {\r\n      return formatDistanceToNow(new Date(date), this.dateFnsLocale);\r\n    }\r\n\r\n    return \"Invalid Date\";\r\n  }\r\n\r\n  //UTC Operations --------------------------------------------------------------\r\n  getUTCToLocalizedDate(key: string) {\r\n    let browserTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;\r\n\r\n    if (key) {\r\n      if (key.indexOf(\"T\") == -1) {\r\n        key = key.replace(\" \", \"T\");\r\n      }\r\n      if (key.indexOf(\"Z\") == -1) {\r\n        key = key + \"Z\";\r\n      }\r\n    }\r\n\r\n    if (browserTimeZone) {\r\n      let localDateTime = utcToZonedTime(key, browserTimeZone);\r\n      return format(localDateTime, 'dd.MM.yyyy', this.dateFnsLocale);\r\n    }\r\n    else {\r\n      return format(new Date(key), 'dd.MM.yyyy', this.dateFnsLocale);\r\n    }\r\n  }\r\n\r\n  getUTCToLocalizedDateTime(key: string) {\r\n    let browserTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;\r\n\r\n    if (key) {\r\n      if (key.indexOf(\"T\") == -1) {\r\n        key = key.replace(\" \", \"T\");\r\n      }\r\n      if (key.indexOf(\"Z\") == -1) {\r\n        key = key + \"Z\";\r\n      }\r\n    }\r\n\r\n    if (browserTimeZone) {\r\n      let localDateTime = utcToZonedTime(key, browserTimeZone);\r\n      return format(localDateTime, 'dd.MM.yyyy HH:mm', this.dateFnsLocale);\r\n    }\r\n    else {\r\n      return format(new Date(key), 'dd.MM.yyyy HH:mm', this.dateFnsLocale);\r\n    }\r\n  }\r\n\r\n  //https://date-fns.org/v1.30.1/docs/distanceInWords\r\n  getUTCToLocalizedDistanceToNowInWords(date: string): string {\r\n    date = this.safeUtcToZonedTime(date);\r\n\r\n    if (isValid(new Date(date))) {\r\n      return formatDistanceToNow(new Date(date), this.dateFnsLocale);\r\n    }\r\n\r\n    return \"Invalid Date\";\r\n  }\r\n  \r\n\r\n  safeUtcToZonedTime(date): string {\r\n    let result = date;\r\n\r\n    try\r\n    {\r\n      if (date) {\r\n        if (date.indexOf(\"T\") == -1) {\r\n          date = date.replace(\" \", \"T\");\r\n        }\r\n\r\n        if (date.indexOf(\"Z\") == -1) {\r\n          date = date + \"Z\";\r\n        }\r\n      }\r\n\r\n      let browserTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;\r\n      if (browserTimeZone) {\r\n        result = utcToZonedTime(date, browserTimeZone).toString();\r\n      }\r\n      else {\r\n        result = new Date(date).toString();\r\n      }\r\n    }\r\n    catch\r\n    {\r\n      if (date) {\r\n        console.log(\"UTC to Local conversion failed for :\" + date.toString())\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n}\r\n\r\n"]}

package/esm2020/lib/core/localization/localizationSettings.module.mjs

@@ -0,0 +1,88 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny
+    Anatoly Osovitny
+
+  Created:
+     05 May 2020
+
+  Version:
+    1.0
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+//Node
+import { NgModule, Injector, APP_INITIALIZER } from '@angular/core';
+import { LOCATION_INITIALIZED } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { TranslateLoader, TranslateModule, TranslateService } from '@ngx-translate/core';
+import { TranslateHttpLoader } from '@ngx-translate/http-loader';
+//App
+import { LocalizationService } from './localization.service';
+import { AppCoreSettings } from '../consts/settings';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export function customTranslateLoaderFactory(http) {
+    return new TranslateHttpLoader(http, AppCoreSettings.resourcesUrl + "/", '.json');
+}
+export function localizationInitializerFactory(translate, localizationService, injector) {
+    return () => new Promise((resolve) => {
+        let locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
+        locationInitialized.then(() => {
+            let languageToSet = localizationService.configureTranslationSettings(translate);
+            translate.use(languageToSet).subscribe(() => {
+            }, () => {
+                resolve(null);
+            }, () => {
+                resolve(null);
+            });
+        });
+    });
+}
+export const TranslateModuleAtRoot = TranslateModule.forRoot({
+    loader: {
+        provide: TranslateLoader,
+        useFactory: customTranslateLoaderFactory,
+        deps: [HttpClient]
+    }
+});
+export let LocalizationInjectorInstance;
+export class LocalizationSettingsModule {
+    constructor(injector) {
+        this.injector = injector;
+        LocalizationInjectorInstance = this.injector;
+    }
+}
+LocalizationSettingsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationSettingsModule, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule });
+LocalizationSettingsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.0.6", ngImport: i0, type: LocalizationSettingsModule, imports: [i1.TranslateModule] });
+LocalizationSettingsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationSettingsModule, providers: [
+        {
+            provide: APP_INITIALIZER,
+            useFactory: localizationInitializerFactory,
+            deps: [TranslateService, LocalizationService, Injector],
+            multi: true
+        }
+    ], imports: [TranslateModuleAtRoot] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizationSettingsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        TranslateModuleAtRoot
+                    ],
+                    providers: [
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: localizationInitializerFactory,
+                            deps: [TranslateService, LocalizationService, Injector],
+                            multi: true
+                        }
+                    ],
+                    exports: []
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/localization/localize.pipe.mjs

@@ -0,0 +1,78 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny
+    Anatoly Osovitny
+
+  Created:
+     10 May 2020
+
+  Version:
+    1.0
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+//Node
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./localization.service";
+export class LocalizePipe {
+    constructor(localizeService) {
+        this.localizeService = localizeService;
+    }
+    transform(inputData, type, param2) {
+        if (!inputData) {
+            return;
+        }
+        if (!type) {
+            type = 'tr';
+        }
+        //Translate
+        if (type === 'tr') {
+            return this.localizeService.getLocalizedValue(inputData);
+        }
+        //Date
+        if (type === 'd') {
+            return this.localizeService.getLocalizedDate(inputData);
+        }
+        //DateTime
+        if (type === 'dt') {
+            return this.localizeService.getLocalizedDateTime(inputData);
+        }
+        //DistanceInWords
+        if (type === 'dis') {
+            return this.localizeService.getLocalizedDistanceInWords(inputData, param2);
+        }
+        //DistanceToNowInWords
+        if (type === 'dis2now') {
+            return this.localizeService.getLocalizedDistanceToNowInWords(inputData);
+        }
+        //UTC Operations --------------------------------------------------------------
+        //UTC Date
+        if (type === 'u2d') {
+            return this.localizeService.getUTCToLocalizedDate(inputData);
+        }
+        //UTC DateTime
+        if (type === 'u2dt') {
+            return this.localizeService.getUTCToLocalizedDateTime(inputData);
+        }
+        //UTC DistanceToNowInWords
+        if (type === 'u2dis2now') {
+            return this.localizeService.getUTCToLocalizedDistanceToNowInWords(inputData);
+        }
+        return inputData;
+    }
+}
+LocalizePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizePipe, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+LocalizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.0.6", ngImport: i0, type: LocalizePipe, name: "localize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'localize'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/core/localization/utils.js → esm2020/lib/core/localization/utils.mjs}

@@ -13,7 +13,7 @@
   Version:
     1.0
 
-  Copyright (c) 2016-2021 Osovitny Inc. All rights reserved.
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
 </file>
 */
 // App
@@ -42,4 +42,4 @@ export class L10nUtils {
         return key;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/logging/globalErrorHandler.mjs

@@ -0,0 +1,44 @@
+/*
+<file>
+  Project:
+    @osovitny/anatoly
+
+  Authors:
+    Vadim Osovitny
+    Anatoly Osovitny
+
+  Created:
+    26 Jun 2020
+
+  Version:
+    1.0
+
+  Copyright (c) 2016-2022 Osovitny Inc. All rights reserved.
+</file>
+*/
+/*
+  https://medium.com/@amcdnl/global-error-handling-with-angular2-6b992bdfb59c
+  https://medium.com/angular-in-depth/expecting-the-unexpected-best-practices-for-error-handling-in-angular-21c3662ef9e4
+*/
+// Node
+import { Injectable } from "@angular/core";
+// App
+import { LoggingService } from "./logging.service";
+import * as i0 from "@angular/core";
+export class GlobalErrorHandler {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    handleError(error) {
+        const loggingService = this.injector.get(LoggingService);
+        loggingService.logError(error);
+        // IMPORTANT: Rethrow the error otherwise it gets swallowed
+        throw error;
+    }
+}
+GlobalErrorHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: GlobalErrorHandler, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+GlobalErrorHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: GlobalErrorHandler });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: GlobalErrorHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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