@pepperi-addons/ngx-lib 0.5.0-ng15.3 → 0.5.0-ng16.1

package/esm2022/core/common/pipes/common-pipes.mjs

@@ -0,0 +1,180 @@
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "../services/utilities.service";
+export class PepCapitalizePipe {
+    transform(value) {
+        if (value) {
+            return value.charAt(0).toUpperCase() + value.slice(1);
+        }
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepCapitalizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepCapitalizePipe, name: "pepCapitalize" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepCapitalizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepCapitalize' }]
+        }] });
+export class PepEncodePipe {
+    transform(value) {
+        if (value) {
+            const v = btoa(value);
+            return v;
+        }
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepEncodePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepEncodePipe, name: "pepEncode" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepEncodePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepEncode' }]
+        }] });
+export class PepEscapePipe {
+    transform(value) {
+        if (value) {
+            const v = escape(value);
+            return v;
+        }
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepEscapePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepEscapePipe, name: "pepEscape" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepEscapePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepEscape' }]
+        }] });
+export class PepReplaceLineBreaksPipe {
+    transform(value) {
+        const newValue = value.replace(/(<br\ ?\/?>)/g, ' ');
+        return newValue;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepReplaceLineBreaksPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepReplaceLineBreaksPipe, name: "pepReplaceLineBreaks" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepReplaceLineBreaksPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepReplaceLineBreaks' }]
+        }] });
+export class PepDateFormatterPipe {
+    transform(value, culture, isDateTime = false) {
+        let res = '';
+        value = new Date(value);
+        if (value) {
+            res = value.toLocaleDateString(culture || 'en-US');
+            if (isDateTime) {
+                res +=
+                    ' ' +
+                        value.toLocaleTimeString(culture || 'en-US', {
+                            hour: '2-digit',
+                            minute: '2-digit',
+                        });
+            }
+        }
+        return res;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepDateFormatterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepDateFormatterPipe, name: "pepDateFormatter" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepDateFormatterPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepDateFormatter' }]
+        }] });
+export class PepDateStringFormatterPipe {
+    transform(value, culture, isDateTime = false) {
+        let res = '';
+        const tmpDate = new Date(value);
+        if (value) {
+            res = tmpDate.toLocaleDateString(culture || 'en-US');
+            if (isDateTime) {
+                res += ' ' + tmpDate.toLocaleTimeString(culture || 'en-US');
+            }
+        }
+        return res;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepDateStringFormatterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepDateStringFormatterPipe, name: "pepDateStringFormatter" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepDateStringFormatterPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepDateStringFormatter' }]
+        }] });
+export class PepSafeHtmlPipe {
+    sanitizer;
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(html) {
+        return this.sanitizer.bypassSecurityTrustHtml(html);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepSafeHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepSafeHtmlPipe, name: "pepSafeHtml" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepSafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepSafeHtml' }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+export class PepSafePipe {
+    sanitizer;
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value, type) {
+        switch (type) {
+            case 'html':
+                return this.sanitizer.bypassSecurityTrustHtml(value);
+            case 'style':
+                return this.sanitizer.bypassSecurityTrustStyle(value);
+            case 'script':
+                return this.sanitizer.bypassSecurityTrustScript(value);
+            case 'url':
+                return this.sanitizer.bypassSecurityTrustUrl(value);
+            case 'resourceUrl':
+                return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+            default:
+                throw new Error(`Invalid safe type specified: ${type}`);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepSafePipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepSafePipe, name: "pepSafe" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepSafePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepSafe' }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+export class PepSplitUppercasePipe {
+    transform(value) {
+        const newValue = value.replace(/([a-z])([A-Z])/g, '$1 $2');
+        return newValue;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepSplitUppercasePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepSplitUppercasePipe, name: "pepSplitUppercase" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepSplitUppercasePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepSplitUppercase' }]
+        }] });
+export class PepToNumberPipe {
+    utilitiesService;
+    constructor(utilitiesService) {
+        this.utilitiesService = utilitiesService;
+    }
+    transform(value) {
+        const decimalSeparator = this.utilitiesService.getDecimalSeparator();
+        // We need to remove the thousands separator so - If the decimal separator is '.' we need to remove the ',' from the value else we remove the '.'.
+        value = decimalSeparator === '.' ? value.replace(/,/g, '') : value.replace(/./g, '');
+        const numberValue = coerceNumberProperty(value);
+        return numberValue;
+        // return parseInt(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepToNumberPipe, deps: [{ token: i2.PepUtilitiesService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PepToNumberPipe, name: "pepToNumber" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepToNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'pepToNumber' }]
+        }], ctorParameters: function () { return [{ type: i2.PepUtilitiesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-pipes.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/common/pipes/common-pipes.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceNumberProperty } from '@angular/cdk/coercion';\nimport { Pipe, PipeTransform } from '@angular/core';\nimport {\n    DomSanitizer,\n    SafeHtml,\n    SafeStyle,\n    SafeScript,\n    SafeUrl,\n    SafeResourceUrl,\n} from '@angular/platform-browser';\nimport { PepUtilitiesService } from '../services/utilities.service';\n\n@Pipe({ name: 'pepCapitalize' })\nexport class PepCapitalizePipe implements PipeTransform {\n    transform(value: any) {\n        if (value) {\n            return value.charAt(0).toUpperCase() + value.slice(1);\n        }\n        return value;\n    }\n}\n\n@Pipe({ name: 'pepEncode' })\nexport class PepEncodePipe implements PipeTransform {\n    transform(value: any) {\n        if (value) {\n            const v = btoa(value);\n            return v;\n        }\n        return value;\n    }\n}\n\ndeclare function escape(s: string): string;\n\n@Pipe({ name: 'pepEscape' })\nexport class PepEscapePipe implements PipeTransform {\n    transform(value: any) {\n        if (value) {\n            const v = escape(value);\n            return v;\n        }\n        return value;\n    }\n}\n\n@Pipe({ name: 'pepReplaceLineBreaks' })\nexport class PepReplaceLineBreaksPipe implements PipeTransform {\n    transform(value: string): string {\n        const newValue = value.replace(/(<br\\ ?\\/?>)/g, ' ');\n        return newValue;\n    }\n}\n\n@Pipe({ name: 'pepDateFormatter' })\nexport class PepDateFormatterPipe implements PipeTransform {\n    transform(value: Date, culture: any, isDateTime = false): string {\n        let res = '';\n        value = new Date(value);\n        if (value) {\n            res = value.toLocaleDateString(culture || 'en-US');\n            if (isDateTime) {\n                res +=\n                    ' ' +\n                    value.toLocaleTimeString(culture || 'en-US', {\n                        hour: '2-digit',\n                        minute: '2-digit',\n                    });\n            }\n        }\n        return res;\n    }\n}\n\n@Pipe({ name: 'pepDateStringFormatter' })\nexport class PepDateStringFormatterPipe implements PipeTransform {\n    transform(value: string, culture: any, isDateTime = false): string {\n        let res = '';\n        const tmpDate = new Date(value);\n        if (value) {\n            res = tmpDate.toLocaleDateString(culture || 'en-US');\n            if (isDateTime) {\n                res += ' ' + tmpDate.toLocaleTimeString(culture || 'en-US');\n            }\n        }\n        return res;\n    }\n}\n\n@Pipe({ name: 'pepSafeHtml' })\nexport class PepSafeHtmlPipe implements PipeTransform {\n    constructor(private sanitizer: DomSanitizer) {}\n\n    transform(html) {\n        return this.sanitizer.bypassSecurityTrustHtml(html);\n    }\n}\n\n@Pipe({ name: 'pepSafe' })\nexport class PepSafePipe implements PipeTransform {\n    constructor(protected sanitizer: DomSanitizer) {}\n\n    public transform(\n        value: any,\n        type: string\n    ): SafeHtml | SafeStyle | SafeScript | SafeUrl | SafeResourceUrl {\n        switch (type) {\n            case 'html':\n                return this.sanitizer.bypassSecurityTrustHtml(value);\n\n            case 'style':\n                return this.sanitizer.bypassSecurityTrustStyle(value);\n\n            case 'script':\n                return this.sanitizer.bypassSecurityTrustScript(value);\n\n            case 'url':\n                return this.sanitizer.bypassSecurityTrustUrl(value);\n\n            case 'resourceUrl':\n                return this.sanitizer.bypassSecurityTrustResourceUrl(value);\n\n            default:\n                throw new Error(`Invalid safe type specified: ${type}`);\n        }\n    }\n}\n\n@Pipe({ name: 'pepSplitUppercase' })\nexport class PepSplitUppercasePipe implements PipeTransform {\n    transform(value: string): string {\n        const newValue = value.replace(/([a-z])([A-Z])/g, '$1 $2');\n        return newValue;\n    }\n}\n\n@Pipe({ name: 'pepToNumber' })\nexport class PepToNumberPipe implements PipeTransform {\n    constructor(private utilitiesService: PepUtilitiesService) {}\n\n    transform(value: string): number {\n        const decimalSeparator = this.utilitiesService.getDecimalSeparator();\n        // We need to remove the thousands separator so - If the decimal separator is '.' we need to remove the ',' from the value else we remove the '.'.\n        value = decimalSeparator === '.' ? value.replace(/,/g, '') : value.replace(/./g, '');\n        const numberValue = coerceNumberProperty(value);\n        return numberValue;\n        // return parseInt(value);\n    }\n}\n"]}

package/esm2022/core/common/pipes/date-ago.pipe.mjs

@@ -0,0 +1,47 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class DateAgoPipe {
+    translateService;
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    getCounterTranslation(counter, key) {
+        const intervalText = this.translateService.get(`DATE_AGO.${key.toUpperCase()}`) || key;
+        const agoText = this.translateService.get(counter === 1 ? 'DATE_AGO.SINGULAR' : 'DATE_AGO.PLURAL') || counter === 1 ? ' ago' : 's ago';
+        return `${intervalText}${agoText}`;
+    }
+    transform(value, args) {
+        if (value) {
+            const seconds = Math.floor((+new Date() - +new Date(value)) / 1000);
+            if (seconds < 29) // less than 30 seconds ago will show as 'Just now'
+                return this.translateService.get('DATE_AGO.JUST_NOW') || 'Just now';
+            const intervals = {
+                'year': 31536000,
+                'month': 2592000,
+                'week': 604800,
+                'day': 86400,
+                'hour': 3600,
+                'minute': 60,
+                'second': 1
+            };
+            let counter;
+            for (const i in intervals) {
+                counter = Math.floor(seconds / intervals[i]);
+                if (counter > 0) {
+                    this.getCounterTranslation(counter, i);
+                }
+            }
+        }
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateAgoPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: DateAgoPipe, name: "dateAgo" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DateAgoPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateAgo'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/common/services/addon.service.mjs

@@ -0,0 +1,234 @@
+import { Injectable, Optional } from '@angular/core';
+import { createCustomElement } from '@angular/elements';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "./session.service";
+import * as i2 from "../../http/services/http.service";
+import * as i3 from "../../http/services/loader.service";
+import * as i4 from "./translate.service";
+import * as i5 from "./file.service";
+import * as i6 from "@angular/router";
+/*
+    This service is the webapp api for addon usege.
+*/
+export class PepAddonService {
+    sessionService;
+    httpService;
+    loaderService;
+    translateService;
+    fileService;
+    router;
+    route;
+    PAGES_ADDON_UUID = '50062e0c-9967-4ed4-9102-f2bc50602d41';
+    // private readonly ADDON_ASSETS_PATH_KEY = 'AddonAssetsPath';
+    ADDONS_DICTIONARY_ASSETS_PATH_KEY = 'AddonsDictionaryAssetsPath';
+    ADDON_API_RELATIVE_PATH = '/addons/api';
+    ADDON_API_ASYNC_RELATIVE_PATH = `${this.ADDON_API_RELATIVE_PATH}/async`;
+    static _customElementsMap = new Map();
+    get devServer() {
+        return this.route ? this.route.snapshot.queryParamMap.get('devServer') === 'true' : false;
+    }
+    constructor(sessionService, httpService, loaderService, translateService, fileService, router, route) {
+        this.sessionService = sessionService;
+        this.httpService = httpService;
+        this.loaderService = loaderService;
+        this.translateService = translateService;
+        this.fileService = fileService;
+        this.router = router;
+        this.route = route;
+        //
+    }
+    getAddonBaseRelativePath(isAsync = false) {
+        return isAsync
+            ? this.ADDON_API_ASYNC_RELATIVE_PATH
+            : this.ADDON_API_RELATIVE_PATH;
+    }
+    getAddonStaticFolder(addonUUID) {
+        // if (addonUUID.length > 0) {
+        const addonsDictionary = this.sessionService.getObject(this.ADDONS_DICTIONARY_ASSETS_PATH_KEY);
+        return addonsDictionary && addonsDictionary[addonUUID] ? addonsDictionary[addonUUID] : '';
+        // } else {
+        // return this.sessionService.getObject(this.ADDON_ASSETS_PATH_KEY) || '';
+        // }
+    }
+    setAddonStaticFolder(path, addonUUID) {
+        // if (addonUUID.length > 0) {
+        const addonsDictionary = this.sessionService.getObject(this.ADDONS_DICTIONARY_ASSETS_PATH_KEY) ?? {};
+        addonsDictionary[addonUUID] = path;
+        this.sessionService.setObject(this.ADDONS_DICTIONARY_ASSETS_PATH_KEY, addonsDictionary);
+        // } else {
+        //     return this.sessionService.setObject(this.ADDON_ASSETS_PATH_KEY, path);
+        // }
+    }
+    getServerBaseUrl(addonUUID, fileName = '', isAsync = false, localhostPort = 4500) {
+        const fileToAdd = fileName.length > 0 ? `/${fileName}` : '';
+        // For devServer run server on localhost.
+        if (this.devServer) {
+            return `http://localhost:${localhostPort}${fileToAdd}`;
+        }
+        else {
+            const baseUrl = this.sessionService.getPapiBaseUrl();
+            return `${baseUrl}${this.getAddonBaseRelativePath(isAsync)}/${addonUUID}${fileToAdd}`;
+        }
+    }
+    getAddonApiCall(addonUUID, fileName, functionName, httpOptions = {}, isAsync = false) {
+        // return this.httpService.getPapiApiCall(
+        //     `${this.getAddonBaseRelativePath(
+        //         isAsync
+        //     )}/${addonUUID}/${fileName}/${functionName}`,
+        //     httpOptions
+        // );
+        const papiBaseUrl = this.getServerBaseUrl(addonUUID, fileName, isAsync);
+        return this.httpService.getHttpCall(`${papiBaseUrl}/${functionName}`, httpOptions);
+    }
+    postAddonApiCall(addonUUID, fileName, functionName, body = {}, httpOptions = {}, isAsync = false) {
+        // return this.httpService.postPapiApiCall(
+        //     `${this.getAddonBaseRelativePath(
+        //         isAsync
+        //     )}/${addonUUID}/${fileName}/${functionName}`,
+        //     body,
+        //     httpOptions
+        // );
+        const papiBaseUrl = this.getServerBaseUrl(addonUUID, fileName, isAsync);
+        return this.httpService.postHttpCall(`${papiBaseUrl}/${functionName}`, body, httpOptions);
+    }
+    async getAddonCPICall(addonUUID, url) {
+        const res = await this.emitEvent("AddonAPI", {
+            AddonUUID: addonUUID,
+            RelativeURL: url,
+        });
+        if (res.Success) {
+            return JSON.parse(res.Value);
+        }
+        else {
+            throw new Error(res.Value);
+        }
+    }
+    async postAddonCPICall(addonUUID, url, body) {
+        const res = await this.emitEvent("AddonAPI", {
+            AddonUUID: addonUUID,
+            RelativeURL: url,
+            Method: 'POST',
+            Body: body
+        });
+        if (res.Success) {
+            return JSON.parse(res.Value);
+        }
+        else {
+            throw new Error(res.Value);
+        }
+    }
+    emitEvent(eventKey, eventData) {
+        return new Promise(resolve => {
+            window.dispatchEvent(new CustomEvent('emit-event', {
+                detail: {
+                    eventKey,
+                    eventData: eventData,
+                    completion: resolve
+                }
+            }));
+        });
+    }
+    // TODO: need to chek this if the loader is working.
+    fetch(input, init) {
+        this.loaderService.show();
+        return window.fetch(input, init).finally(() => {
+            this.loaderService.hide();
+        });
+    }
+    getNgxLibTranslationResource(addonUUID, libName = 'ngx-lib') {
+        const addonStaticFolder = this.getAddonStaticFolder(addonUUID);
+        const translationsPath = this.fileService.getAssetsTranslationsPath(addonStaticFolder, libName);
+        const translationsSuffix = this.fileService.getAssetsTranslationsSuffix(libName);
+        return {
+            prefix: translationsPath,
+            suffix: translationsSuffix,
+        };
+    }
+    getAddonTranslationResource(addonUUID) {
+        const addonStaticFolder = this.getAddonStaticFolder(addonUUID);
+        const defaultSubFolder = 'assets/i18n/';
+        return {
+            prefix: addonStaticFolder.length > 0 ? `${addonStaticFolder}${defaultSubFolder}` : `/${defaultSubFolder}`,
+            suffix: '.json',
+        };
+    }
+    setDefaultTranslateLang(translate, urlLangParam = 'userLang') {
+        this.translateService.setDefaultTranslateLang(translate, urlLangParam);
+    }
+    getPagesAddonUUID() {
+        return this.PAGES_ADDON_UUID;
+    }
+    setShellRouterData(data) {
+        const eventData = {
+            detail: data,
+        };
+        const customEvent = new CustomEvent('set-router-data', eventData);
+        window.dispatchEvent(customEvent);
+    }
+    defineCustomElement(elementName, component, injector) {
+        if (!customElements.get(elementName)) {
+            customElements.define(elementName, createCustomElement(component, { injector: injector }));
+            // Set the elementName in the _customElementsMap (Fix internal routing bug).
+            PepAddonService._customElementsMap.set(elementName, { injector: injector });
+        }
+    }
+    // Fix internal routing bug.
+    connectInternalRouter(elementName) {
+        const customElementObject = PepAddonService._customElementsMap.get(elementName);
+        let router = customElementObject?.injector.get(Router);
+        // This cause a refresh (everithing is loading twice) when reloading the page...
+        // But if we remove this the first navigation is clear all history cause the router is not connected.
+        if (!router) {
+            router = this.router;
+        }
+        if (router) {
+            const useHash = location.href.includes('#');
+            this.connectRouter(router, useHash);
+        }
+    }
+    connectRouter(router, useHash = false) {
+        let url;
+        if (!useHash) {
+            url = `${location.pathname.substr(1)}${location.search}`;
+            router.navigateByUrl(url);
+            window.addEventListener('popstate', () => {
+                router.navigateByUrl(url);
+            });
+        }
+        else {
+            url = `${location.hash.substr(1)}${location.search}`;
+            router.navigateByUrl(url);
+            window.addEventListener('hashchange', () => {
+                router.navigateByUrl(url);
+            });
+        }
+    }
+    static createMultiTranslateLoader(addonUUID, addonService, libsName = ['ngx-lib']) {
+        const ngxLibTranslationResources = [];
+        if (libsName?.length > 0) {
+            for (let index = 0; index < libsName.length; index++) {
+                const libName = libsName[index];
+                ngxLibTranslationResources.push(addonService.getNgxLibTranslationResource(addonUUID, libName));
+            }
+        }
+        const addonTranslationResource = addonService.getAddonTranslationResource(addonUUID);
+        return addonService.translateService.createMultiTranslateLoader([
+            ...ngxLibTranslationResources,
+            addonTranslationResource
+        ]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepAddonService, deps: [{ token: i1.PepSessionService }, { token: i2.PepHttpService }, { token: i3.PepLoaderService }, { token: i4.PepTranslateService }, { token: i5.PepFileService }, { token: i6.Router, optional: true }, { token: i6.ActivatedRoute, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepAddonService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PepAddonService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PepSessionService }, { type: i2.PepHttpService }, { type: i3.PepLoaderService }, { type: i4.PepTranslateService }, { type: i5.PepFileService }, { type: i6.Router, decorators: [{
+                    type: Optional
+                }] }, { type: i6.ActivatedRoute, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addon.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/common/services/addon.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, Optional, Type } from '@angular/core';\nimport { createCustomElement } from '@angular/elements';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { PepSessionService } from './session.service';\nimport { PepFileService } from './file.service';\nimport { PepHttpService } from '../../http/services/http.service';\nimport { PepLoaderService } from '../../http/services/loader.service';\nimport { Observable } from 'rxjs';\nimport { HttpClient } from '@angular/common/http';\nimport { TranslateService } from '@ngx-translate/core';\nimport { ITranslationResource } from 'ngx-translate-multi-http-loader';\nimport { PepTranslateService } from './translate.service';\nimport { connectRouter } from '@angular-architects/module-federation-tools';\n\n/*\n    This service is the webapp api for addon usege.\n*/\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepAddonService {\n    private readonly PAGES_ADDON_UUID = '50062e0c-9967-4ed4-9102-f2bc50602d41';\n    // private readonly ADDON_ASSETS_PATH_KEY = 'AddonAssetsPath';\n    private readonly ADDONS_DICTIONARY_ASSETS_PATH_KEY = 'AddonsDictionaryAssetsPath';\n    private readonly ADDON_API_RELATIVE_PATH = '/addons/api';\n    private readonly ADDON_API_ASYNC_RELATIVE_PATH = `${this.ADDON_API_RELATIVE_PATH}/async`;\n\n    private static _customElementsMap: Map<string, any> = new Map();\n\n    public get devServer() {\n        return this.route ? this.route.snapshot.queryParamMap.get('devServer') === 'true' : false;\n    }\n\n    constructor(\n        private sessionService: PepSessionService,\n        private httpService: PepHttpService,\n        private loaderService: PepLoaderService,\n        public translateService: PepTranslateService,\n        public fileService: PepFileService,\n        @Optional() private router: Router,\n        @Optional() private route: ActivatedRoute,\n    ) {\n        //\n    }\n\n    private getAddonBaseRelativePath(isAsync = false): string {\n        return isAsync\n            ? this.ADDON_API_ASYNC_RELATIVE_PATH\n            : this.ADDON_API_RELATIVE_PATH;\n    }\n\n    getAddonStaticFolder(addonUUID: string): string {\n        // if (addonUUID.length > 0) {\n            const addonsDictionary = this.sessionService.getObject(this.ADDONS_DICTIONARY_ASSETS_PATH_KEY);\n            return addonsDictionary && addonsDictionary[addonUUID] ? addonsDictionary[addonUUID] : '';\n        // } else {\n            // return this.sessionService.getObject(this.ADDON_ASSETS_PATH_KEY) || '';\n        // }\n    }\n\n    setAddonStaticFolder(path: string, addonUUID: string): void {\n        // if (addonUUID.length > 0) {\n            const addonsDictionary = this.sessionService.getObject(this.ADDONS_DICTIONARY_ASSETS_PATH_KEY) ?? {};\n            addonsDictionary[addonUUID] = path;\n            this.sessionService.setObject(this.ADDONS_DICTIONARY_ASSETS_PATH_KEY, addonsDictionary);\n        // } else {\n        //     return this.sessionService.setObject(this.ADDON_ASSETS_PATH_KEY, path);\n        // }\n    }\n\n    getServerBaseUrl(addonUUID: string, fileName = '', isAsync = false, localhostPort = 4500): string {\n        const fileToAdd = fileName.length > 0 ? `/${fileName}` : '';\n        \n        // For devServer run server on localhost.\n        if(this.devServer) {\n            return `http://localhost:${localhostPort}${fileToAdd}`;\n        } else {\n            const baseUrl = this.sessionService.getPapiBaseUrl();\n            return `${baseUrl}${this.getAddonBaseRelativePath(isAsync)}/${addonUUID}${fileToAdd}`;\n        }\n    }\n\n    getAddonApiCall(\n        addonUUID: string,\n        fileName: string,\n        functionName: string,\n        httpOptions = {},\n        isAsync = false\n    ): Observable<any> {\n        // return this.httpService.getPapiApiCall(\n        //     `${this.getAddonBaseRelativePath(\n        //         isAsync\n        //     )}/${addonUUID}/${fileName}/${functionName}`,\n        //     httpOptions\n        // );\n\n        const papiBaseUrl = this.getServerBaseUrl(addonUUID, fileName, isAsync);\n        return this.httpService.getHttpCall(`${papiBaseUrl}/${functionName}`, httpOptions);\n    }\n\n    postAddonApiCall(\n        addonUUID: string,\n        fileName: string,\n        functionName: string,\n        body = {},\n        httpOptions = {},\n        isAsync = false\n    ): Observable<any> {\n        // return this.httpService.postPapiApiCall(\n        //     `${this.getAddonBaseRelativePath(\n        //         isAsync\n        //     )}/${addonUUID}/${fileName}/${functionName}`,\n        //     body,\n        //     httpOptions\n        // );\n\n        const papiBaseUrl = this.getServerBaseUrl(addonUUID, fileName, isAsync);\n        return this.httpService.postHttpCall(`${papiBaseUrl}/${functionName}`, body, httpOptions);\n    }\n\n    async getAddonCPICall(\n        addonUUID: string,\n        url: string\n    ) {\n        const res = await this.emitEvent(\"AddonAPI\", {\n            AddonUUID: addonUUID,\n            RelativeURL: url,\n        })\n\n        if (res.Success) {\n            return JSON.parse(res.Value)\n        }\n        else {\n            throw new Error(res.Value)\n        }\n    }\n\n    async postAddonCPICall(\n        addonUUID: string,\n        url: string,\n        body: any\n    ) {\n        const res = await this.emitEvent(\"AddonAPI\", {\n            AddonUUID: addonUUID,\n            RelativeURL: url,\n            Method: 'POST',\n            Body: body\n        })\n\n        if (res.Success) {\n            return JSON.parse(res.Value)\n        }\n        else {\n            throw new Error(res.Value)\n        }\n    }   \n\n    emitEvent(eventKey: string, eventData: any): Promise<any> {\n        return new Promise(resolve => {\n            window.dispatchEvent(new CustomEvent('emit-event', {\n                detail: {\n                    eventKey,\n                    eventData: eventData,\n                    completion: resolve\n                }\n            }))\n        })\n    }\n\n    // TODO: need to chek this if the loader is working.\n    fetch(input: RequestInfo, init?: RequestInit): Promise<Response> {\n        this.loaderService.show();\n\n        return window.fetch(input, init).finally(() => {\n            this.loaderService.hide();\n        });\n    }\n\n    getNgxLibTranslationResource(addonUUID: string, libName = 'ngx-lib'): ITranslationResource {\n        const addonStaticFolder = this.getAddonStaticFolder(addonUUID);\n        const translationsPath: string = this.fileService.getAssetsTranslationsPath(addonStaticFolder, libName);\n        const translationsSuffix: string = this.fileService.getAssetsTranslationsSuffix(libName);\n\n        return {\n            prefix: translationsPath,\n            suffix: translationsSuffix,\n        };\n    }\n\n    getAddonTranslationResource(addonUUID: string): ITranslationResource {\n        const addonStaticFolder = this.getAddonStaticFolder(addonUUID);\n        const defaultSubFolder = 'assets/i18n/';\n\n        return {\n            prefix: addonStaticFolder.length > 0 ? `${addonStaticFolder}${defaultSubFolder}` : `/${defaultSubFolder}`,\n            suffix: '.json',\n        };\n    }\n\n    setDefaultTranslateLang(translate: TranslateService, urlLangParam = 'userLang') {\n        this.translateService.setDefaultTranslateLang(translate, urlLangParam);\n    }\n\n    getPagesAddonUUID() {\n        return this.PAGES_ADDON_UUID;\n    }\n\n    setShellRouterData(data: { addPadding?: boolean, showSidebar?: boolean, showHeader?: boolean }) {\n        const eventData = {\n            detail: data,\n        };\n\n        const customEvent = new CustomEvent('set-router-data', eventData);\n        window.dispatchEvent(customEvent);\n    }\n\n    defineCustomElement(elementName: string, component: Type<any>, injector: Injector) {\n        if (!customElements.get(elementName)) {  \n            customElements.define(elementName, createCustomElement(component, {injector: injector}));\n            \n            // Set the elementName in the _customElementsMap (Fix internal routing bug).\n            PepAddonService._customElementsMap.set(elementName, {injector: injector});\n        }\n    }\n\n    // Fix internal routing bug.\n    connectInternalRouter(elementName: string) {\n        const customElementObject = PepAddonService._customElementsMap.get(elementName);\n        let router = customElementObject?.injector.get(Router);\n\n        // This cause a refresh (everithing is loading twice) when reloading the page...\n        // But if we remove this the first navigation is clear all history cause the router is not connected.\n        if (!router) {\n            router = this.router;\n        }\n\n        if (router) {\n            const useHash = location.href.includes('#');\n            this.connectRouter(router, useHash);\n        }\n    }\n    \n    private connectRouter(router, useHash = false) {\n        let url;\n        if (!useHash) {\n            url = `${location.pathname.substr(1)}${location.search}`;\n            router.navigateByUrl(url);\n            window.addEventListener('popstate', () => {\n                router.navigateByUrl(url);\n            });\n        }\n        else {\n            url = `${location.hash.substr(1)}${location.search}`;\n            router.navigateByUrl(url);\n            window.addEventListener('hashchange', () => {\n                router.navigateByUrl(url);\n            });\n        }\n    }\n\n    public static createMultiTranslateLoader(\n        addonUUID: string,\n        addonService: PepAddonService,\n        libsName = ['ngx-lib'],\n    ) {\n        const ngxLibTranslationResources = [];\n\n        if (libsName?.length > 0) {\n            for (let index = 0; index < libsName.length; index++) {\n                const libName = libsName[index];\n                ngxLibTranslationResources.push(addonService.getNgxLibTranslationResource(addonUUID, libName));\n            }\n        }\n\n        const addonTranslationResource = addonService.getAddonTranslationResource(addonUUID);\n\n        return addonService.translateService.createMultiTranslateLoader([\n            ...ngxLibTranslationResources,\n            addonTranslationResource\n        ]);\n    }\n}\n"]}