@pepperi-addons/ngx-lib 0.3.15-beta.8 → 0.4.0-angular14.2

package/esm2020/core/common/services/data-convertor.service.mjs

@@ -0,0 +1,119 @@
+import { Injectable } from '@angular/core';
+import { FieldLayout, ObjectsDataRow, UIControl, UIControlField, ObjectsDataRowCell, X_ALIGNMENT_TYPE, } from '../model/wapi.model';
+import { PepGuid } from '../model/utilities.model';
+import * as i0 from "@angular/core";
+export class PepFieldData {
+    constructor(options = {}) {
+        this.ApiName = options.ApiName;
+        this.Enabled = !!options.Enabled;
+        this.Value = options.Value;
+        this.FormattedValue = options.FormattedValue || '';
+        this.FieldType = options.FieldType;
+        this.ReadOnly = !!options.ReadOnly;
+        this.ColumnWidth = options.ColumnWidth;
+        this.ColumnWidthType = options.ColumnWidthType;
+        this.XAlignment = options.XAlignment || X_ALIGNMENT_TYPE.Left;
+        this.Title = options.Title || '';
+    }
+}
+export class PepRowData {
+}
+export class PepDataConvertorService {
+    getUiControl(formData) {
+        const uiControl = new UIControl();
+        if (formData?.Fields?.length > 0) {
+            const uiRow = formData.Fields;
+            uiControl.ControlFields = [];
+            uiRow.forEach((field) => uiControl.ControlFields.push(this.setUIControlField(field)));
+        }
+        return uiControl;
+    }
+    convertFormData(formData) {
+        const rowData = new ObjectsDataRow();
+        rowData.Fields = [];
+        rowData.Type = 0;
+        rowData.UID = PepGuid.newGuid();
+        formData.Fields.forEach((field) => rowData.Fields.push(this.setDataField(field)));
+        return rowData;
+    }
+    convertListData(tableData, rowUUID = '') {
+        const rows = new Array();
+        if (tableData.length > 0) {
+            tableData.forEach((row) => {
+                const rowData = new ObjectsDataRow();
+                rowData.Fields = [];
+                rowData.Type = 0;
+                rowData.UID = rowUUID
+                    ? rowUUID
+                    : row.UUID
+                        ? row.UUID
+                        : PepGuid.newGuid();
+                if (row.IsEditable === false) {
+                    rowData.IsEditable = false;
+                }
+                if (row.IsSelectableForActions === false) {
+                    rowData.IsSelectableForActions = false;
+                }
+                row.Fields.forEach((field) => rowData.Fields.push(this.setDataField(field)));
+                rows.push(rowData);
+            });
+        }
+        return rows;
+    }
+    setUIControlField(field) {
+        const controlField = new UIControlField();
+        controlField.ApiName = field.ApiName;
+        controlField.FieldType = field.FieldType;
+        controlField.Layout = new FieldLayout({
+            X: 1,
+            Width: 1,
+            XAlignment: field.XAlignment,
+            Y: 1,
+            Height: 1,
+            YAlignment: 1,
+        });
+        controlField.Title = field.Title;
+        controlField.ReadOnly = field.ReadOnly === true ? true : false;
+        controlField.ColumnWidth = field.ColumnWidth;
+        controlField.ColumnWidthType = field.ColumnWidthType || 1;
+        return controlField;
+    }
+    setDataField(field) {
+        const dataField = new ObjectsDataRowCell();
+        dataField.AdditionalValue = field.AdditionalValue;
+        dataField.ApiName = field.ApiName;
+        dataField.Enabled = field.Enabled === false ? false : true;
+        dataField.FieldType = field.FieldType;
+        dataField.FormattedValue =
+            field.FormattedValue || field.Value.toString();
+        dataField.GroupFields = null;
+        dataField.NotificationInfo = '';
+        dataField.OptionalValues = field.OptionalValues;
+        dataField.ReferenceObjectSubType = '';
+        dataField.TextColor = '';
+        dataField.Value = field.Value.toString();
+        dataField.Visible = true;
+        return dataField;
+    }
+    setFieldLayout(x, width, xAlignment, y, height, yAlignment, lineNumber) {
+        const layout = new FieldLayout({
+            X: x,
+            Width: width,
+            XAlignment: xAlignment,
+            Y: y,
+            Height: height,
+            YAlignment: yAlignment,
+            LineNumber: lineNumber,
+        });
+        return layout;
+    }
+}
+PepDataConvertorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepDataConvertorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepDataConvertorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepDataConvertorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepDataConvertorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-convertor.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/common/services/data-convertor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n    FieldLayout,\n    ObjectsDataRow,\n    UIControl,\n    UIControlField,\n    ObjectsDataRowCell,\n    FIELD_TYPE,\n    X_ALIGNMENT_TYPE,\n} from '../model/wapi.model';\nimport { PepGuid } from '../model/utilities.model';\n\nexport class PepFieldData {\n    ApiName: string;\n    Enabled?: boolean;\n    Value: string;\n    FormattedValue?: string;\n    FieldType: FIELD_TYPE;\n    ReadOnly?: boolean;\n    ColumnWidth: number;\n    ColumnWidthType?: number;\n    XAlignment: X_ALIGNMENT_TYPE;\n    Title: string;\n    AdditionalValue?: string;\n    OptionalValues?: any;\n\n    constructor(\n        options: {\n            ApiName?: string;\n            Enabled?: boolean;\n            Value?: string;\n            FormattedValue?: string;\n            FieldType?: FIELD_TYPE;\n            ReadOnly?: boolean;\n            ColumnWidth?: number;\n            ColumnWidthType?: number;\n            XAlignment?: X_ALIGNMENT_TYPE;\n            Title?: string;\n        } = {}\n    ) {\n        this.ApiName = options.ApiName;\n        this.Enabled = !!options.Enabled;\n        this.Value = options.Value;\n        this.FormattedValue = options.FormattedValue || '';\n        this.FieldType = options.FieldType;\n        this.ReadOnly = !!options.ReadOnly;\n        this.ColumnWidth = options.ColumnWidth;\n        this.ColumnWidthType = options.ColumnWidthType;\n        this.XAlignment = options.XAlignment || X_ALIGNMENT_TYPE.Left;\n        this.Title = options.Title || '';\n    }\n}\nexport class PepRowData {\n    UUID?: string;\n    IsEditable?: boolean;\n    IsSelectableForActions?: boolean;\n    Fields: PepFieldData[];\n}\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepDataConvertorService {\n    getUiControl(formData: PepRowData): UIControl {\n        const uiControl = new UIControl();\n\n        if (formData?.Fields?.length > 0) {\n            const uiRow = formData.Fields;\n            uiControl.ControlFields = [];\n            uiRow.forEach((field) =>\n                uiControl.ControlFields.push(this.setUIControlField(field))\n            );\n        }\n\n        return uiControl;\n    }\n\n    convertFormData(formData: PepRowData): ObjectsDataRow {\n        const rowData = new ObjectsDataRow();\n        rowData.Fields = [];\n        rowData.Type = 0;\n        rowData.UID = PepGuid.newGuid();\n        formData.Fields.forEach((field) =>\n            rowData.Fields.push(this.setDataField(field))\n        );\n\n        return rowData;\n    }\n\n    convertListData(\n        tableData: PepRowData[],\n        rowUUID = ''\n    ): Array<ObjectsDataRow> {\n        const rows = new Array<ObjectsDataRow>();\n\n        if (tableData.length > 0) {\n            tableData.forEach((row) => {\n                const rowData = new ObjectsDataRow();\n                rowData.Fields = [];\n                rowData.Type = 0;\n                rowData.UID = rowUUID\n                    ? rowUUID\n                    : row.UUID\n                        ? row.UUID\n                        : PepGuid.newGuid();\n                if (row.IsEditable === false) {\n                    rowData.IsEditable = false;\n                }\n                if (row.IsSelectableForActions === false) {\n                    rowData.IsSelectableForActions = false;\n                }\n                row.Fields.forEach((field) =>\n                    rowData.Fields.push(this.setDataField(field))\n                );\n                rows.push(rowData);\n            });\n        }\n\n        return rows;\n    }\n\n    setUIControlField(field: PepFieldData): UIControlField {\n        const controlField = new UIControlField();\n        controlField.ApiName = field.ApiName;\n        controlField.FieldType = field.FieldType;\n\n        controlField.Layout = new FieldLayout({\n            X: 1,\n            Width: 1,\n            XAlignment: field.XAlignment,\n            Y: 1,\n            Height: 1,\n            YAlignment: 1,\n        });\n\n        controlField.Title = field.Title;\n        controlField.ReadOnly = field.ReadOnly === true ? true : false;\n        controlField.ColumnWidth = field.ColumnWidth;\n        controlField.ColumnWidthType = field.ColumnWidthType || 1;\n        return controlField;\n    }\n\n    setDataField(field: PepFieldData): ObjectsDataRowCell {\n        const dataField = new ObjectsDataRowCell();\n        dataField.AdditionalValue = field.AdditionalValue;\n        dataField.ApiName = field.ApiName;\n        dataField.Enabled = field.Enabled === false ? false : true;\n        dataField.FieldType = field.FieldType;\n        dataField.FormattedValue =\n            field.FormattedValue || field.Value.toString();\n        dataField.GroupFields = null;\n        dataField.NotificationInfo = '';\n        dataField.OptionalValues = field.OptionalValues;\n        dataField.ReferenceObjectSubType = '';\n        dataField.TextColor = '';\n        dataField.Value = field.Value.toString();\n        dataField.Visible = true;\n        return dataField;\n    }\n\n    setFieldLayout(\n        x: number,\n        width: number,\n        xAlignment: number,\n        y: number,\n        height: number,\n        yAlignment: number,\n        lineNumber: number\n    ): FieldLayout {\n        const layout = new FieldLayout({\n            X: x,\n            Width: width,\n            XAlignment: xAlignment,\n            Y: y,\n            Height: height,\n            YAlignment: yAlignment,\n            LineNumber: lineNumber,\n        });\n\n        return layout;\n    }\n}\n"]}

package/esm2020/core/common/services/file.service.mjs

@@ -0,0 +1,213 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PepFileService {
+    constructor() {
+        this.scripts = new Map();
+        this.styles = new Map();
+    }
+    loadFiles(files) {
+        const promises = [];
+        files.forEach((file) => {
+            if (file.type === 'style') {
+                promises.push(this.loadStyle(file.path));
+            }
+            else if (file.type === 'script') {
+                promises.push(this.loadScript(file.path));
+            }
+        });
+        return Promise.all(promises);
+    }
+    removeFiles(files) {
+        for (let index = 0; index < files.length &&
+            files[index].path &&
+            files[index].path.trim() !== ''; index++) {
+            const name = this.getFileName(files[index].path, true);
+            const element = document.getElementById(name);
+            element.parentNode.removeChild(element);
+            if (files[index].type === 'script' && this.scripts.has(name)) {
+                this.scripts.delete(name);
+            }
+            else if (files[index].type === 'style' && this.styles.has(name)) {
+                this.styles.delete(name);
+            }
+        }
+    }
+    loadScript(path) {
+        return new Promise((resolve, reject) => {
+            const name = this.getFileName(path, true);
+            // If the script isn't exist add it.
+            if (!this.scripts.has(name)) {
+                this.scripts.set(name, { loaded: false, src: path });
+            }
+            const scriptItem = this.scripts.get(name);
+            // Resolve if already loaded
+            if (scriptItem.loaded) {
+                resolve({
+                    script: name,
+                    loaded: true,
+                    status: 'Already Loaded',
+                });
+            }
+            else {
+                // Load script
+                const script = document.createElement('script');
+                script.type = 'text/javascript';
+                script.src = scriptItem.src;
+                script.setAttribute('id', name);
+                script.async = false;
+                if (script.readyState) {
+                    // IE
+                    script.onreadystatechange = () => {
+                        if (script.readyState === 'loaded' ||
+                            script.readyState === 'complete') {
+                            script.onreadystatechange = null;
+                            scriptItem.loaded = true;
+                            resolve({
+                                path,
+                                type: 'script',
+                                loaded: true,
+                                status: 'Loaded',
+                            });
+                        }
+                    };
+                }
+                else {
+                    // Others
+                    script.onload = () => {
+                        scriptItem.loaded = true;
+                        resolve({
+                            path,
+                            type: 'script',
+                            loaded: true,
+                            status: 'Loaded',
+                        });
+                    };
+                }
+                script.onerror = (error) => resolve({
+                    path,
+                    type: 'script',
+                    loaded: false,
+                    status: 'Loaded',
+                });
+                document.getElementsByTagName('head')[0].appendChild(script);
+            }
+        });
+    }
+    loadStyle(path) {
+        return new Promise((resolve, reject) => {
+            const name = this.getFileName(path, true);
+            // If the style isn't exist add it.
+            if (!this.styles.has(name)) {
+                this.styles.set(name, { loaded: false, src: path });
+            }
+            const styleItem = this.styles.get(name);
+            // Resolve if already loaded
+            if (styleItem.loaded) {
+                resolve({
+                    path,
+                    type: 'style',
+                    loaded: true,
+                    status: 'Already Loaded',
+                });
+            }
+            else {
+                // Load style
+                const style = document.createElement('link');
+                style.type = 'text/css';
+                style.rel = 'stylesheet';
+                style.href = styleItem.src;
+                style.media = 'all';
+                style.setAttribute('id', name);
+                styleItem.loaded = true;
+                resolve({
+                    path,
+                    type: 'style',
+                    loaded: true,
+                    status: 'Loaded',
+                });
+                document.getElementsByTagName('head')[0].appendChild(style);
+            }
+        });
+    }
+    loadFontStyle(styleId, href) {
+        const head = document.getElementsByTagName('head')[0];
+        const styleElement = document.getElementById(styleId);
+        if (styleElement) {
+            styleElement.href = href;
+        }
+        else {
+            const style = document.createElement('link');
+            style.id = styleId;
+            style.rel = 'stylesheet';
+            style.href = `${href}`;
+            head.appendChild(style);
+        }
+    }
+    getFileName(filePath, withExtenstion = false) {
+        const lastIndex = withExtenstion
+            ? filePath.length - 1
+            : filePath.lastIndexOf('.');
+        return filePath.substr(filePath.lastIndexOf('/') + 1, lastIndex);
+    }
+    getFileExtension(filePath) {
+        const fileSplit = filePath.split('.');
+        let fileExt = '';
+        if (fileSplit.length > 1) {
+            fileExt = fileSplit[fileSplit.length - 2];
+        }
+        return fileExt;
+    }
+    /* Returns true if url is valid */
+    isValidUrl(url) {
+        /* Try creating a valid URL */
+        try {
+            const tmp = new URL(url);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    convertFromb64toBlob(b64Data, contentType = '', sliceSize = 512) {
+        const byteCharacters = atob(b64Data);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+            const slice = byteCharacters.slice(offset, offset + sliceSize);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: contentType });
+        return blob;
+    }
+    getAssetsPath(assetsDomain = '', libName = 'ngx-lib') {
+        const concatChar = assetsDomain === '' || assetsDomain.endsWith('/') ? '' : '/';
+        return `${assetsDomain}${concatChar}assets/${libName}/`;
+    }
+    getAssetsTranslationsSuffix(libName = 'ngx-lib') {
+        return `.${libName}.json`;
+    }
+    getAssetsTranslationsPath(assetsDomain = '', libName = 'ngx-lib') {
+        return `${this.getAssetsPath(assetsDomain, libName)}i18n/`;
+    }
+    getAssetsImagesPath(assetsDomain = '', image = '', libName = 'ngx-lib') {
+        return `${this.getAssetsPath(assetsDomain, libName)}images/${image}`;
+    }
+    getSvgAsImageSrc(svg) {
+        const blob = new Blob([svg], { type: 'image/svg+xml' });
+        const url = URL.createObjectURL(blob);
+        return url;
+    }
+}
+PepFileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepFileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepFileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepFileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepFileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/common/services/file.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nexport type PepFileType = 'script' | 'style';\n\nexport interface IPepExternalFileModel {\n    path: string;\n    type: PepFileType;\n}\n\ndeclare let document: any;\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepFileService {\n    private scripts: Map<string, { loaded: boolean; src: string }>;\n    private styles: Map<string, { loaded: boolean; src: string }>;\n\n    constructor() {\n        this.scripts = new Map<string, { loaded: boolean; src: string }>();\n        this.styles = new Map<string, { loaded: boolean; src: string }>();\n    }\n\n    loadFiles(files: IPepExternalFileModel[]): Promise<any[]> {\n        const promises: any[] = [];\n        files.forEach((file) => {\n            if (file.type === 'style') {\n                promises.push(this.loadStyle(file.path));\n            } else if (file.type === 'script') {\n                promises.push(this.loadScript(file.path));\n            }\n        });\n        return Promise.all(promises);\n    }\n\n    removeFiles(files: IPepExternalFileModel[]): void {\n        for (\n            let index = 0;\n            index < files.length &&\n            files[index].path &&\n            files[index].path.trim() !== '';\n            index++\n        ) {\n            const name = this.getFileName(files[index].path, true);\n            const element = document.getElementById(name);\n            element.parentNode.removeChild(element);\n\n            if (files[index].type === 'script' && this.scripts.has(name)) {\n                this.scripts.delete(name);\n            } else if (files[index].type === 'style' && this.styles.has(name)) {\n                this.styles.delete(name);\n            }\n        }\n    }\n\n    loadScript(path: string): Promise<any> {\n        return new Promise((resolve, reject) => {\n            const name = this.getFileName(path, true);\n\n            // If the script isn't exist add it.\n            if (!this.scripts.has(name)) {\n                this.scripts.set(name, { loaded: false, src: path });\n            }\n\n            const scriptItem = this.scripts.get(name);\n\n            // Resolve if already loaded\n            if (scriptItem.loaded) {\n                resolve({\n                    script: name,\n                    loaded: true,\n                    status: 'Already Loaded',\n                });\n            } else {\n                // Load script\n                const script = document.createElement('script');\n                script.type = 'text/javascript';\n                script.src = scriptItem.src;\n                script.setAttribute('id', name);\n                script.async = false;\n\n                if (script.readyState) {\n                    // IE\n                    script.onreadystatechange = () => {\n                        if (\n                            script.readyState === 'loaded' ||\n                            script.readyState === 'complete'\n                        ) {\n                            script.onreadystatechange = null;\n                            scriptItem.loaded = true;\n                            resolve({\n                                path,\n                                type: 'script',\n                                loaded: true,\n                                status: 'Loaded',\n                            });\n                        }\n                    };\n                } else {\n                    // Others\n                    script.onload = () => {\n                        scriptItem.loaded = true;\n                        resolve({\n                            path,\n                            type: 'script',\n                            loaded: true,\n                            status: 'Loaded',\n                        });\n                    };\n                }\n                script.onerror = (error: any) =>\n                    resolve({\n                        path,\n                        type: 'script',\n                        loaded: false,\n                        status: 'Loaded',\n                    });\n                document.getElementsByTagName('head')[0].appendChild(script);\n            }\n        });\n    }\n\n    loadStyle(path: string): Promise<any> {\n        return new Promise((resolve, reject) => {\n            const name = this.getFileName(path, true);\n\n            // If the style isn't exist add it.\n            if (!this.styles.has(name)) {\n                this.styles.set(name, { loaded: false, src: path });\n            }\n\n            const styleItem = this.styles.get(name);\n\n            // Resolve if already loaded\n            if (styleItem.loaded) {\n                resolve({\n                    path,\n                    type: 'style',\n                    loaded: true,\n                    status: 'Already Loaded',\n                });\n            } else {\n                // Load style\n                const style = document.createElement('link');\n                style.type = 'text/css';\n                style.rel = 'stylesheet';\n                style.href = styleItem.src;\n                style.media = 'all';\n                style.setAttribute('id', name);\n\n                styleItem.loaded = true;\n                resolve({\n                    path,\n                    type: 'style',\n                    loaded: true,\n                    status: 'Loaded',\n                });\n\n                document.getElementsByTagName('head')[0].appendChild(style);\n            }\n        });\n    }\n\n    loadFontStyle(styleId: string, href: string): void {\n        const head = document.getElementsByTagName('head')[0];\n\n        const styleElement = document.getElementById(\n            styleId\n        ) as HTMLLinkElement;\n\n        if (styleElement) {\n            styleElement.href = href;\n        } else {\n            const style = document.createElement('link');\n            style.id = styleId;\n            style.rel = 'stylesheet';\n            style.href = `${href}`;\n\n            head.appendChild(style);\n        }\n    }\n\n    getFileName(filePath: string, withExtenstion = false): string {\n        const lastIndex = withExtenstion\n            ? filePath.length - 1\n            : filePath.lastIndexOf('.');\n\n        return filePath.substr(filePath.lastIndexOf('/') + 1, lastIndex);\n    }\n\n    getFileExtension(filePath: string): string {\n        const fileSplit = filePath.split('.');\n        let fileExt = '';\n        if (fileSplit.length > 1) {\n            fileExt = fileSplit[fileSplit.length - 2];\n        }\n        return fileExt;\n    }\n\n    /* Returns true if url is valid */\n    isValidUrl(url: string): boolean {\n        /* Try creating a valid URL */\n        try {\n            const tmp = new URL(url);\n            return true;\n        } catch (e) {\n            return false;\n        }\n    }\n\n    convertFromb64toBlob(\n        b64Data: any,\n        contentType = '',\n        sliceSize = 512\n    ): Blob {\n        const byteCharacters = atob(b64Data);\n        const byteArrays = [];\n\n        for (\n            let offset = 0;\n            offset < byteCharacters.length;\n            offset += sliceSize\n        ) {\n            const slice = byteCharacters.slice(offset, offset + sliceSize);\n\n            const byteNumbers = new Array(slice.length);\n            for (let i = 0; i < slice.length; i++) {\n                byteNumbers[i] = slice.charCodeAt(i);\n            }\n\n            const byteArray = new Uint8Array(byteNumbers);\n            byteArrays.push(byteArray);\n        }\n\n        const blob = new Blob(byteArrays, { type: contentType });\n        return blob;\n    }\n\n    getAssetsPath(assetsDomain = '', libName = 'ngx-lib'): string {\n        const concatChar =\n            assetsDomain === '' || assetsDomain.endsWith('/') ? '' : '/';\n        return `${assetsDomain}${concatChar}assets/${libName}/`;\n    }\n\n    getAssetsTranslationsSuffix(libName = 'ngx-lib'): string {\n        return `.${libName}.json`;\n    }\n\n    getAssetsTranslationsPath(assetsDomain = '', libName = 'ngx-lib'): string {\n        return `${this.getAssetsPath(assetsDomain, libName)}i18n/`;\n    }\n\n    getAssetsImagesPath(assetsDomain = '', image = '', libName = 'ngx-lib'): string {\n        return `${this.getAssetsPath(assetsDomain, libName)}images/${image}`;\n    }\n\n    getSvgAsImageSrc(svg: string): string {\n        const blob = new Blob([svg], { type: 'image/svg+xml' });\n        const url = URL.createObjectURL(blob);\n        return url;\n    }\n}\n"]}

package/esm2020/core/common/services/jwt-helper.service.mjs

@@ -0,0 +1,106 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PepJwtHelperService {
+    urlBase64Decode(str) {
+        let output = str.replace(/-/g, '+').replace(/_/g, '/');
+        switch (output.length % 4) {
+            case 0: {
+                break;
+            }
+            case 2: {
+                output += '==';
+                break;
+            }
+            case 3: {
+                output += '=';
+                break;
+            }
+            default: {
+                throw new Error('Illegal base64url string!');
+            }
+        }
+        return this.b64DecodeUnicode(output);
+    }
+    // credits for decoder goes to https://github.com/atk
+    b64decode(str) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        let output = '';
+        str = String(str).replace(/=+$/, '');
+        if (str.length % 4 === 1) {
+            throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
+        }
+        for (
+        // initialize result and counters
+        let bc = 0, bs, buffer, idx = 0; 
+        // get next character
+        (buffer = str.charAt(idx++)); 
+        // character found in table? initialize bit storage and add its ascii value;
+        ~buffer &&
+            ((bs = bc % 4 ? bs * 64 + buffer : buffer),
+                // and if not first of each 4 characters,
+                // convert the first 8 bits to one ascii character
+                bc++ % 4)
+            ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
+            : 0) {
+            // try to find character in table (0-63, not found => -1)
+            buffer = chars.indexOf(buffer);
+        }
+        return output;
+    }
+    b64DecodeUnicode(str) {
+        return decodeURIComponent(Array.prototype.map
+            .call(this.b64decode(str), (c) => {
+            return ('%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2));
+        })
+            .join(''));
+    }
+    decodeToken(token) {
+        if (!token || token === '') {
+            return null;
+        }
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error("The inspected token doesn't appear to be a JWT. Check to make sure it has three parts and see https://jwt.io for more.");
+        }
+        const decoded = this.urlBase64Decode(parts[1]);
+        if (!decoded) {
+            throw new Error('Cannot decode the token.');
+        }
+        return JSON.parse(decoded);
+    }
+    getTokenExpirationDate(token) {
+        const decoded = this.decodeToken(token);
+        if (!decoded || !decoded.hasOwnProperty('exp')) {
+            return null;
+        }
+        const date = new Date(0);
+        date.setUTCSeconds(decoded.exp);
+        return date;
+    }
+    isTokenExpired(token, offsetSeconds) {
+        if (!token || token === '') {
+            return true;
+        }
+        const date = this.getTokenExpirationDate(token);
+        offsetSeconds = offsetSeconds || 0;
+        if (date === null) {
+            return false;
+        }
+        return !(date.valueOf() > new Date().valueOf() + offsetSeconds * 1000);
+    }
+    getAuthScheme(authScheme, request) {
+        if (typeof authScheme === 'function') {
+            return authScheme(request);
+        }
+        return authScheme;
+    }
+}
+PepJwtHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepJwtHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepJwtHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepJwtHelperService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepJwtHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jwt-helper.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-lib/src/core/common/services/jwt-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpRequest } from '@angular/common/http';\nimport { Injectable, Inject } from '@angular/core';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PepJwtHelperService {\n    public urlBase64Decode(str: string): string {\n        let output = str.replace(/-/g, '+').replace(/_/g, '/');\n        switch (output.length % 4) {\n            case 0: {\n                break;\n            }\n            case 2: {\n                output += '==';\n                break;\n            }\n            case 3: {\n                output += '=';\n                break;\n            }\n            default: {\n                throw new Error('Illegal base64url string!');\n            }\n        }\n        return this.b64DecodeUnicode(output);\n    }\n\n    // credits for decoder goes to https://github.com/atk\n    private b64decode(str: string): string {\n        const chars =\n            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n        let output = '';\n\n        str = String(str).replace(/=+$/, '');\n\n        if (str.length % 4 === 1) {\n            throw new Error(\n                \"'atob' failed: The string to be decoded is not correctly encoded.\"\n            );\n        }\n\n        for (\n            // initialize result and counters\n            let bc = 0, bs: any, buffer: any, idx = 0;\n            // get next character\n            (buffer = str.charAt(idx++));\n            // character found in table? initialize bit storage and add its ascii value;\n            ~buffer &&\n            ((bs = bc % 4 ? bs * 64 + buffer : buffer),\n            // and if not first of each 4 characters,\n            // convert the first 8 bits to one ascii character\n            bc++ % 4)\n                ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))\n                : 0\n        ) {\n            // try to find character in table (0-63, not found => -1)\n            buffer = chars.indexOf(buffer);\n        }\n        return output;\n    }\n\n    private b64DecodeUnicode(str: any): string {\n        return decodeURIComponent(\n            Array.prototype.map\n                .call(this.b64decode(str), (c: any) => {\n                    return (\n                        '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)\n                    );\n                })\n                .join('')\n        );\n    }\n\n    public decodeToken(token: string): any {\n        if (!token || token === '') {\n            return null;\n        }\n\n        const parts = token.split('.');\n\n        if (parts.length !== 3) {\n            throw new Error(\n                \"The inspected token doesn't appear to be a JWT. Check to make sure it has three parts and see https://jwt.io for more.\"\n            );\n        }\n\n        const decoded = this.urlBase64Decode(parts[1]);\n        if (!decoded) {\n            throw new Error('Cannot decode the token.');\n        }\n\n        return JSON.parse(decoded);\n    }\n\n    public getTokenExpirationDate(token: string): Date | null {\n        const decoded = this.decodeToken(token);\n\n        if (!decoded || !decoded.hasOwnProperty('exp')) {\n            return null;\n        }\n\n        const date = new Date(0);\n        date.setUTCSeconds(decoded.exp);\n\n        return date;\n    }\n\n    public isTokenExpired(token: string, offsetSeconds?: number): boolean {\n        if (!token || token === '') {\n            return true;\n        }\n        const date = this.getTokenExpirationDate(token);\n        offsetSeconds = offsetSeconds || 0;\n\n        if (date === null) {\n            return false;\n        }\n\n        return !(date.valueOf() > new Date().valueOf() + offsetSeconds * 1000);\n    }\n\n    public getAuthScheme(\n        authScheme: (request: HttpRequest<any>) => any | string | undefined,\n        request: HttpRequest<any>\n    ): string {\n        if (typeof authScheme === 'function') {\n            return authScheme(request);\n        }\n\n        return authScheme;\n    }\n}\n"]}

package/esm2020/core/common/services/session.service.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./jwt-helper.service";
+export class PepSessionService {
+    // private readonly PEPPERI_CONSUMER_TOKEN: 'YY2pAwx6Exo2LWXrUllF9xzSfWF53wqc';
+    constructor(jwtHelper) {
+        this.jwtHelper = jwtHelper;
+        this.IDP_TOKEN_KEY = 'idp_token';
+        this.PAPI_BASE_URL_KEY = 'pepperi.baseurl';
+        // private readonly WAPI_TOKEN_KEY = 'auth_token';
+        this.WAPI_BASE_URL_KEY = 'serverHostURL'; // pepperi.webapibaseurl
+    }
+    getParseToken() {
+        // debugger;
+        // const tokenTest = "eyJhbGciOiJSUzI1NiIsImtpZCI6IjRiYTFjNzJmMTI3NThjYzEzMzg3ZWQ3YTBiZjNlODg3IiwidHlwIjoiSldUIn0.eyJuYmYiOjE1OTY3MjU5NjksImV4cCI6MTU5NjcyNjI2OSwiaXNzIjoiaHR0cHM6Ly9pZHAuc2FuZGJveC5wZXBwZXJpLmNvbSIsImF1ZCI6InBlcHBlcmkud2ViYXBwLmFwcC5zYW5kYm94LnBlcHBlcmkuY29tIiwiaWF0IjoxNTk2NzI1OTY5LCJhdF9oYXNoIjoiSGtmRXJ0Q2JzQ3NzOTVKUm05VmJTdyIsInNpZCI6IjJkNzFiM2JiNWUyNjRiNDk2Y2JmZDkzNmYyNTNhNWIzIiwic3ViIjoiZTJkZmQ0MDYtZDM4Yy00ZmYwLThhZGItMWRlMjI3ODIzYWEyIiwiYXV0aF90aW1lIjoxNTk2NzE4ODA5LCJpZHAiOiJsb2NhbCIsIm5hbWUiOiJkYW5pZWwgZGF2aWRvZmYiLCJlbWFpbCI6ImRhbmllbC5kQHBlcHBlcml0ZXN0LmNvbSIsInBlcHBlcmkuaWQiOjg2OTAzMDQsInBlcHBlcmkudXNlcnV1aWQiOiJlMmRmZDQwNi1kMzhjLTRmZjAtOGFkYi0xZGUyMjc4MjNhYTIiLCJwZXBwZXJpLmRpc3RyaWJ1dG9yaWQiOjMwMDEyMzUxLCJwZXBwZXJpLmRpc3RyaWJ1dG9ydXVpZCI6IjBiZDBlZDc5LThlOWUtNDRmYi05NmY0LThlNTNlZDljZTgyYiIsInBlcHBlcmkuZGF0YWNlbnRlciI6InNhbmRib3giLCJwZXBwZXJpLmtlZXBsb2dpbiI6ZmFsc2UsInBlcHBlcmkuaWRsZXRpbWV3ZWIiOjEyMCwidXBkYXRlZF9hdCI6MTU5NjcwMjgwMCwiZ2l2ZW5fbmFtZSI6ImRhbmllbCIsImZhbWlseV9uYW1lIjoiZGF2aWRvZmYiLCJwZXBwZXJpLmFwaW50YmFzZXVybCI6Imh0dHBzOi8vcmVzdGFwaS5zYW5kYm94LnBlcHBlcmkuY29tIiwicGVwcGVyaS53ZWJhcGliYXNldXJsIjoiaHR0cHM6Ly93ZWJhcGkuc2FuZGJveC5wZXBwZXJpLmNvbS9WMTZfNTAvV2ViQXBwXzYiLCJwZXBwZXJpLnB1YmxpY2FwaWJhc2V1cmwiOiJodHRwczovL2FwaS1zYW5kYm94LnBlcHBlcmkuY29tIiwicGVwcGVyaS5iYXNldXJsIjoiaHR0cHM6Ly9wYXBpLnNhbmRib3gucGVwcGVyaS5jb20vVjEuMCIsInBlcHBlcmkuZW1wbG95ZWV0eXBlIjoxLCJhbXIiOlsicHdkIl19.tNtZT3Cl4dMmTQftoaO2KP5BvHOlWGIP-5GpHrAhZoymBkxBSxpKprQGqr0ATtQlNHjX3gDV1W6k_avaSkyJgDiB2hcwr1tNRilasNuMzNV93gxLC9Oh_HdkIN4cZ0hahIcJvf_17PHpS8zD_MRwvGG_i45wRYJAtiGXChxCMzooethRsLOq5TEwuNbE3MxdjZOpImGYyytmsfdsdJRWQn1LQwQBt95ssuypcUzBsVB34P5XuFttjAe9dhTwHIfgsPG-VdfAWH_r-hVe834wKpKrplSWlC_MucgS0X4XP_tN4CtLnHO2wXKPsojqSTH2NQycfqh6YvT6rzRDBEdQIQ";
+        const token = this.getIdpToken();
+        // token = token || tokenTest;
+        const decodedToken = this.jwtHelper.decodeToken(token);
+        // const expirationDate = this.jwtHelper.getTokenExpirationDate(token);
+        // const isExpired = this.jwtHelper.isTokenExpired(token);
+        return decodedToken;
+    }
+    setObject(key, object) {
+        const stringifiedObject = typeof object === 'string' || object instanceof String
+            ? object
+            : JSON.stringify(object);
+        sessionStorage.setItem(key, stringifiedObject.toString());
+    }
+    getObject(key) {
+        let result = null;
+        const item = sessionStorage.getItem(key);
+        try {
+            result = item ? JSON.parse(item) : item;
+        }
+        catch {
+            result = item;
+        }
+        return result;
+    }
+    // setObject(key: string, value: string): void {
+    //     sessionStorage.setItem(key, value);
+    // }
+    // getObject(key: string): string | null {
+    //     return sessionStorage.getItem(key);
+    // }
+    removeObject(key) {
+        sessionStorage.removeItem(key);
+    }
+    // getWapiToken(): string {
+    //     return this.getObject(this.WAPI_TOKEN_KEY);
+    // }
+    getWapiBaseUrl() {
+        return this.getObject(this.WAPI_BASE_URL_KEY);
+    }
+    getIdpToken() {
+        return this.getObject(this.IDP_TOKEN_KEY);
+    }
+    getPapiBaseUrl() {
+        const tokenObj = this.getParseToken();
+        return tokenObj ? tokenObj[this.PAPI_BASE_URL_KEY] : null;
+    }
+}
+PepSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepSessionService, deps: [{ token: i1.PepJwtHelperService }], target: i0.ɵɵFactoryTarget.Injectable });
+PepSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepSessionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.1", ngImport: i0, type: PepSessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PepJwtHelperService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWxpYi9zcmMvY29yZS9jb21tb24vc2VydmljZXMvc2Vzc2lvbi5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQU0zQyxNQUFNLE9BQU8saUJBQWlCO0lBSzFCLCtFQUErRTtJQUUvRSxZQUFvQixTQUE4QjtRQUE5QixjQUFTLEdBQVQsU0FBUyxDQUFxQjtRQU5qQyxrQkFBYSxHQUFHLFdBQVcsQ0FBQztRQUM1QixzQkFBaUIsR0FBRyxpQkFBaUIsQ0FBQztRQUN2RCxrREFBa0Q7UUFDakMsc0JBQWlCLEdBQUcsZUFBZSxDQUFDLENBQUMsd0JBQXdCO0lBR3pCLENBQUM7SUFFOUMsYUFBYTtRQUNqQixZQUFZO1FBQ1osMnVEQUEydUQ7UUFDM3VELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqQyw4QkFBOEI7UUFFOUIsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDdkQsdUVBQXVFO1FBQ3ZFLDBEQUEwRDtRQUUxRCxPQUFPLFlBQVksQ0FBQztJQUN4QixDQUFDO0lBRUQsU0FBUyxDQUFJLEdBQVcsRUFBRSxNQUFTO1FBQy9CLE1BQU0saUJBQWlCLEdBQ25CLE9BQU8sTUFBTSxLQUFLLFFBQVEsSUFBSSxNQUFNLFlBQVksTUFBTTtZQUNsRCxDQUFDLENBQUMsTUFBTTtZQUNSLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBRWpDLGNBQWMsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLGlCQUFpQixDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVELFNBQVMsQ0FBVSxHQUFXO1FBQzFCLElBQUksTUFBTSxHQUFHLElBQUksQ0FBQztRQUNsQixNQUFNLElBQUksR0FBRyxjQUFjLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBRXpDLElBQUk7WUFDQSxNQUFNLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBRSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7U0FDbEQ7UUFBQyxNQUFNO1lBQ0osTUFBTSxHQUFHLElBQUksQ0FBQztTQUNqQjtRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2xCLENBQUM7SUFFRCxnREFBZ0Q7SUFDaEQsMENBQTBDO0lBQzFDLElBQUk7SUFFSiwwQ0FBMEM7SUFDMUMsMENBQTBDO0lBQzFDLElBQUk7SUFFSixZQUFZLENBQUMsR0FBVztRQUNwQixjQUFjLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFRCwyQkFBMkI7SUFDM0Isa0RBQWtEO0lBQ2xELElBQUk7SUFFSixjQUFjO1FBQ1YsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFRCxXQUFXO1FBQ1AsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBRUQsY0FBYztRQUNWLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUN0QyxPQUFPLFFBQVEsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFDOUQsQ0FBQzs7OEdBdkVRLGlCQUFpQjtrSEFBakIsaUJBQWlCLGNBRmQsTUFBTTsyRkFFVCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUGVwSnd0SGVscGVyU2VydmljZSB9IGZyb20gJy4vand0LWhlbHBlci5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoe1xuICAgIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgUGVwU2Vzc2lvblNlcnZpY2Uge1xuICAgIHByaXZhdGUgcmVhZG9ubHkgSURQX1RPS0VOX0tFWSA9ICdpZHBfdG9rZW4nO1xuICAgIHByaXZhdGUgcmVhZG9ubHkgUEFQSV9CQVNFX1VSTF9LRVkgPSAncGVwcGVyaS5iYXNldXJsJztcbiAgICAvLyBwcml2YXRlIHJlYWRvbmx5IFdBUElfVE9LRU5fS0VZID0gJ2F1dGhfdG9rZW4nO1xuICAgIHByaXZhdGUgcmVhZG9ubHkgV0FQSV9CQVNFX1VSTF9LRVkgPSAnc2VydmVySG9zdFVSTCc7IC8vIHBlcHBlcmkud2ViYXBpYmFzZXVybFxuICAgIC8vIHByaXZhdGUgcmVhZG9ubHkgUEVQUEVSSV9DT05TVU1FUl9UT0tFTjogJ1lZMnBBd3g2RXhvMkxXWHJVbGxGOXh6U2ZXRjUzd3FjJztcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgand0SGVscGVyOiBQZXBKd3RIZWxwZXJTZXJ2aWNlKSB7fVxuXG4gICAgcHJpdmF0ZSBnZXRQYXJzZVRva2VuKCk6IGFueSB7XG4gICAgICAgIC8vIGRlYnVnZ2VyO1xuICAgICAgICAvLyBjb25zdCB0b2tlblRlc3QgPSBcImV5SmhiR2NpT2lKU1V6STFOaUlzSW10cFpDSTZJalJpWVRGak56Sm1NVEkzTlRoall6RXpNemczWldRM1lUQmlaak5sT0RnM0lpd2lkSGx3SWpvaVNsZFVJbjAuZXlKdVltWWlPakUxT1RZM01qVTVOamtzSW1WNGNDSTZNVFU1TmpjeU5qSTJPU3dpYVhOeklqb2lhSFIwY0hNNkx5OXBaSEF1YzJGdVpHSnZlQzV3WlhCd1pYSnBMbU52YlNJc0ltRjFaQ0k2SW5CbGNIQmxjbWt1ZDJWaVlYQndMbUZ3Y0M1ellXNWtZbTk0TG5CbGNIQmxjbWt1WTI5dElpd2lhV0YwSWpveE5UazJOekkxT1RZNUxDSmhkRjlvWVhOb0lqb2lTR3RtUlhKMFEySnpRM056T1RWS1VtMDVWbUpUZHlJc0luTnBaQ0k2SWpKa056RmlNMkppTldVeU5qUmlORGsyWTJKbVpEa3pObVl5TlROaE5XSXpJaXdpYzNWaUlqb2laVEprWm1RME1EWXRaRE00WXkwMFptWXdMVGhoWkdJdE1XUmxNakkzT0RJellXRXlJaXdpWVhWMGFGOTBhVzFsSWpveE5UazJOekU0T0RBNUxDSnBaSEFpT2lKc2IyTmhiQ0lzSW01aGJXVWlPaUprWVc1cFpXd2daR0YyYVdSdlptWWlMQ0psYldGcGJDSTZJbVJoYm1sbGJDNWtRSEJsY0hCbGNtbDBaWE4wTG1OdmJTSXNJbkJsY0hCbGNta3VhV1FpT2pnMk9UQXpNRFFzSW5CbGNIQmxjbWt1ZFhObGNuVjFhV1FpT2lKbE1tUm1aRFF3Tmkxa016aGpMVFJtWmpBdE9HRmtZaTB4WkdVeU1qYzRNak5oWVRJaUxDSndaWEJ3WlhKcExtUnBjM1J5YVdKMWRHOXlhV1FpT2pNd01ERXlNelV4TENKd1pYQndaWEpwTG1ScGMzUnlhV0oxZEc5eWRYVnBaQ0k2SWpCaVpEQmxaRGM1TFRobE9XVXRORFJtWWkwNU5tWTBMVGhsTlRObFpEbGpaVGd5WWlJc0luQmxjSEJsY21rdVpHRjBZV05sYm5SbGNpSTZJbk5oYm1SaWIzZ2lMQ0p3WlhCd1pYSnBMbXRsWlhCc2IyZHBiaUk2Wm1Gc2MyVXNJbkJsY0hCbGNta3VhV1JzWlhScGJXVjNaV0lpT2pFeU1Dd2lkWEJrWVhSbFpGOWhkQ0k2TVRVNU5qY3dNamd3TUN3aVoybDJaVzVmYm1GdFpTSTZJbVJoYm1sbGJDSXNJbVpoYldsc2VWOXVZVzFsSWpvaVpHRjJhV1J2Wm1ZaUxDSndaWEJ3WlhKcExtRndhVzUwWW1GelpYVnliQ0k2SW1oMGRIQnpPaTh2Y21WemRHRndhUzV6WVc1a1ltOTRMbkJsY0hCbGNta3VZMjl0SWl3aWNHVndjR1Z5YVM1M1pXSmhjR2xpWVhObGRYSnNJam9pYUhSMGNITTZMeTkzWldKaGNHa3VjMkZ1WkdKdmVDNXdaWEJ3WlhKcExtTnZiUzlXTVRaZk5UQXZWMlZpUVhCd1h6WWlMQ0p3WlhCd1pYSnBMbkIxWW14cFkyRndhV0poYzJWMWNtd2lPaUpvZEhSd2N6b3ZMMkZ3YVMxellXNWtZbTk0TG5CbGNIQmxjbWt1WTI5dElpd2ljR1Z3Y0dWeWFTNWlZWE5sZFhKc0lqb2lhSFIwY0hNNkx5OXdZWEJwTG5OaGJtUmliM2d1Y0dWd2NHVnlhUzVqYjIwdlZqRXVNQ0lzSW5CbGNIQmxjbWt1Wlcxd2JHOTVaV1YwZVhCbElqb3hMQ0poYlhJaU9sc2ljSGRrSWwxOS50TnRaVDNDbDRkTW1UUWZ0b2FPMktQNUJ2SE9sV0dJUC01R3BIckFoWm95bUJreEJTeHBLcHJRR3FyMEFUdFFsTkhqWDNnRFYxVzZrX2F2YVNreUpnRGlCMmhjd3IxdE5SaWxhc051TXpOVjkzZ3hMQzlPaF9IZGtJTjRjWjBoYWhJY0p2Zl8xN1BIcFM4ekRfTVJ3dkdHX2k0NXdSWUpBdGlHWENoeENNem9vZXRoUnNMT3E1VEV3dU5iRTNNeGRqWk9wSW1HWXl5dG1zZmRzZEpSV1FuMUxRd1FCdDk1c3N1eXBjVXpCc1ZCMzRQNVh1RnR0akFlOWRoVHdISWZnc1BHLVZkZkFXSF9yLWhWZTgzNHdLcEtycGxTV2xDX011Y2dTMFg0WFBfdE40Q3RMbkhPMndYS1Bzb2pxU1RIMk5ReWNmcWg2WXZUNnJ6UkRCRWRRSVFcIjtcbiAgICAgICAgY29uc3QgdG9rZW4gPSB0aGlzLmdldElkcFRva2VuKCk7XG4gICAgICAgIC8vIHRva2VuID0gdG9rZW4gfHwgdG9rZW5UZXN0O1xuXG4gICAgICAgIGNvbnN0IGRlY29kZWRUb2tlbiA9IHRoaXMuand0SGVscGVyLmRlY29kZVRva2VuKHRva2VuKTtcbiAgICAgICAgLy8gY29uc3QgZXhwaXJhdGlvbkRhdGUgPSB0aGlzLmp3dEhlbHBlci5nZXRUb2tlbkV4cGlyYXRpb25EYXRlKHRva2VuKTtcbiAgICAgICAgLy8gY29uc3QgaXNFeHBpcmVkID0gdGhpcy5qd3RIZWxwZXIuaXNUb2tlbkV4cGlyZWQodG9rZW4pO1xuXG4gICAgICAgIHJldHVybiBkZWNvZGVkVG9rZW47XG4gICAgfVxuXG4gICAgc2V0T2JqZWN0PFQ+KGtleTogc3RyaW5nLCBvYmplY3Q6IFQpOiB2b2lkIHtcbiAgICAgICAgY29uc3Qgc3RyaW5naWZpZWRPYmplY3QgPVxuICAgICAgICAgICAgdHlwZW9mIG9iamVjdCA9PT0gJ3N0cmluZycgfHwgb2JqZWN0IGluc3RhbmNlb2YgU3RyaW5nXG4gICAgICAgICAgICAgICAgPyBvYmplY3RcbiAgICAgICAgICAgICAgICA6IEpTT04uc3RyaW5naWZ5KG9iamVjdCk7XG5cbiAgICAgICAgc2Vzc2lvblN0b3JhZ2Uuc2V0SXRlbShrZXksIHN0cmluZ2lmaWVkT2JqZWN0LnRvU3RyaW5nKCkpO1xuICAgIH1cblxuICAgIGdldE9iamVjdDxUID0gYW55PihrZXk6IHN0cmluZyk6IFQge1xuICAgICAgICBsZXQgcmVzdWx0ID0gbnVsbDtcbiAgICAgICAgY29uc3QgaXRlbSA9IHNlc3Npb25TdG9yYWdlLmdldEl0ZW0oa2V5KTtcblxuICAgICAgICB0cnkge1xuICAgICAgICAgICAgcmVzdWx0ID0gaXRlbSA/IChKU09OLnBhcnNlKGl0ZW0pIGFzIFQpIDogaXRlbTtcbiAgICAgICAgfSBjYXRjaCB7XG4gICAgICAgICAgICByZXN1bHQgPSBpdGVtO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIHJlc3VsdDtcbiAgICB9XG5cbiAgICAvLyBzZXRPYmplY3Qoa2V5OiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcpOiB2b2lkIHtcbiAgICAvLyAgICAgc2Vzc2lvblN0b3JhZ2Uuc2V0SXRlbShrZXksIHZhbHVlKTtcbiAgICAvLyB9XG5cbiAgICAvLyBnZXRPYmplY3Qoa2V5OiBzdHJpbmcpOiBzdHJpbmcgfCBudWxsIHtcbiAgICAvLyAgICAgcmV0dXJuIHNlc3Npb25TdG9yYWdlLmdldEl0ZW0oa2V5KTtcbiAgICAvLyB9XG5cbiAgICByZW1vdmVPYmplY3Qoa2V5OiBzdHJpbmcpOiB2b2lkIHtcbiAgICAgICAgc2Vzc2lvblN0b3JhZ2UucmVtb3ZlSXRlbShrZXkpO1xuICAgIH1cblxuICAgIC8vIGdldFdhcGlUb2tlbigpOiBzdHJpbmcge1xuICAgIC8vICAgICByZXR1cm4gdGhpcy5nZXRPYmplY3QodGhpcy5XQVBJX1RPS0VOX0tFWSk7XG4gICAgLy8gfVxuXG4gICAgZ2V0V2FwaUJhc2VVcmwoKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuZ2V0T2JqZWN0KHRoaXMuV0FQSV9CQVNFX1VSTF9LRVkpO1xuICAgIH1cblxuICAgIGdldElkcFRva2VuKCk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiB0aGlzLmdldE9iamVjdCh0aGlzLklEUF9UT0tFTl9LRVkpO1xuICAgIH1cblxuICAgIGdldFBhcGlCYXNlVXJsKCk6IHN0cmluZyB7XG4gICAgICAgIGNvbnN0IHRva2VuT2JqID0gdGhpcy5nZXRQYXJzZVRva2VuKCk7XG4gICAgICAgIHJldHVybiB0b2tlbk9iaiA/IHRva2VuT2JqW3RoaXMuUEFQSV9CQVNFX1VSTF9LRVldIDogbnVsbDtcbiAgICB9XG59XG4iXX0=