ng-pli-commons 0.0.1573 → 0.0.1575

package/README.md

@@ -0,0 +1,24 @@
+# NgPliCommons
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project ng-pli-commons` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project ng-pli-commons`.
+> Note: Don't forget to add `--project ng-pli-commons` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build ng-pli-commons` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build ng-pli-commons`, go to the dist folder `cd dist/ng-pli-commons` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test ng-pli-commons` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/esm2020/lib/components/backoffice.commons.component.mjs

@@ -0,0 +1,40 @@
+import { Component } from '@angular/core';
+import { CommonListsComponent } from './common.lists.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/common.service";
+export class BackofficeCommonsComponent extends CommonListsComponent {
+    constructor(commonService, cdRef) {
+        super(commonService, cdRef);
+        this.commonService = commonService;
+        this.cdRef = cdRef;
+        this.fullWidth = false;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (this.fullWidth) {
+            const element = document.getElementById('mainContainer');
+            if (element) {
+                element.classList.remove('container');
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.fullWidth) {
+            const element = document.getElementById('mainContainer');
+            if (element) {
+                element.classList.add('container');
+            }
+        }
+    }
+}
+BackofficeCommonsComponent.BEST_SCENARIO_COLUMN_ID = '-6';
+BackofficeCommonsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: BackofficeCommonsComponent, deps: [{ token: i1.CommonService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+BackofficeCommonsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: BackofficeCommonsComponent, selector: "app-backoffice-commons", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: BackofficeCommonsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-backoffice-commons',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CommonService }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/common.lists.component.mjs

@@ -0,0 +1,194 @@
+import { Inject, LOCALE_ID, Component } from '@angular/core';
+import { UtilString, primeLocaleEs, EPermission, DateUtil } from 'ng-pli-util';
+import { FormUtil } from '../utils/form-util';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/common.service";
+export class CommonListsComponent {
+    constructor(commonService, cdRef) {
+        this.commonService = commonService;
+        this.cdRef = cdRef;
+    }
+    ngOnInit() {
+        this.onCurrencyInit();
+        this.primeLocaleEs = primeLocaleEs;
+    }
+    /** It prints the monCode */
+    printCurrencyCode(currency) {
+        return currency.monCodigoIso + '-' + currency.monMoneda;
+    }
+    /**
+     * Init the info of currencies
+     */
+    onCurrencyInit() {
+        // Subcription to the currency Subject
+        this.commonService.onCurrencyChanged().subscribe((lCurrency) => {
+            if (lCurrency) {
+                this.lCurrency = lCurrency;
+                this.lSICurrency = [];
+                for (let key in this.lCurrency) {
+                    let currency = this.lCurrency[key];
+                    this.lSICurrency.push({
+                        label: this.printCurrencyCode(currency),
+                        value: currency
+                    });
+                }
+            }
+        });
+        // Subcription to the category Subject
+        this.commonService.onCategoryChanged().subscribe((lCategory) => {
+            if (lCategory) {
+                this.lCategory = lCategory;
+                this.lSICategory = [];
+                for (let key in this.lCategory) {
+                    let category = this.lCategory[key];
+                    this.lSICategory.push({
+                        label: category.rubRubro,
+                        value: category
+                    });
+                }
+            }
+        });
+        // Subcription to the language Subject
+        this.commonService.onLanguageChanged().subscribe((lLanguage) => {
+            if (lLanguage) {
+                this.lLanguage = lLanguage;
+            }
+        });
+        // Subcription to the category Subject
+        this.commonService.onExchangeRateChanged().subscribe((lExchangeRate) => {
+            if (lExchangeRate) {
+                this.lExchangeRate = lExchangeRate;
+                this.adjustmentIsoExchange();
+            }
+        });
+        // Subcription to the category Subject
+        this.commonService.onProcessChanged().subscribe((lProcess) => {
+            if (lProcess) {
+                this.lProcess = lProcess;
+                this.lSIProcess = [];
+                for (let key in this.lProcess) {
+                    let process = this.lProcess[key];
+                    this.lSIProcess.push({
+                        label: process.proNombre,
+                        value: process
+                    });
+                }
+            }
+        });
+        this.commonService.initValues();
+    }
+    adjustmentIsoExchange() {
+        // let i = 0;
+        let lIsoExchage = [];
+        for (let key in this.lExchangeRate) {
+            let exchangeRate = this.lExchangeRate[key];
+            let isoExchage = [];
+            if (lIsoExchage[exchangeRate.monedaOrigen.monCodigoIso] !== undefined) {
+                isoExchage = lIsoExchage[exchangeRate.monedaOrigen.monCodigoIso];
+            }
+            isoExchage[exchangeRate.monedaDestino.monCodigoIso] = exchangeRate;
+            lIsoExchage[exchangeRate.monedaOrigen.monCodigoIso] = isoExchage;
+            // console.log(i);
+            // i++;
+        }
+        if (lIsoExchage) {
+            this.lIsoExchangeRate = [];
+            for (let key in lIsoExchage) {
+                for (let keyIso in lIsoExchage[key]) {
+                    let exchangeRate = lIsoExchage[key][keyIso];
+                    this.lIsoExchangeRate[key + '-' + keyIso] = exchangeRate.tcamTasaCambio;
+                }
+            }
+        }
+    }
+    /** It returns a boolean if the control has any error */
+    hasErrors(formControl) {
+        return FormUtil.hasErrors(formControl);
+    }
+    /** It returns a boolean if the control has a specific error */
+    hasError(formControl, error) {
+        return FormUtil.hasError(formControl, error);
+    }
+    /** It validates if form is valid */
+    isFormValid(formGroup) {
+        FormUtil.validateFormFields(formGroup);
+        if (formGroup.valid) {
+            return true;
+        }
+        else {
+            console.log('Invalid controls: ', FormUtil.getInvalidControls(formGroup));
+            return false;
+        }
+    }
+    copyMessage(val) {
+        UtilString.copyMessage(val);
+    }
+    // ngOnDestroy() {
+    //     try {
+    //         this.commonService.currencyChanged.unsubscribe();
+    //     } catch (error) {
+    //         console.log("commonService.currencyChanged.unsubscribe", error);
+    //     }
+    //     try {
+    //         this.commonService.categoryChanged.unsubscribe();
+    //     } catch (error) {
+    //         console.log("commonService.categoryChanged.unsubscribe", error);
+    //     }
+    //     try {
+    //         this.commonService.exchangeRateChanged.unsubscribe();
+    //     } catch (error) {
+    //         console.log("commonService.exchangeRateChanged.unsubscribe", error);
+    //     }
+    // }
+    /** returns the permission according to x */
+    p(x) {
+        return EPermission[x];
+    }
+    cloneObject(obj) {
+        if (null == obj || 'object' != typeof obj)
+            return obj;
+        var copy = obj.constructor();
+        for (var attr in obj) {
+            if (obj.hasOwnProperty(attr))
+                copy[attr] = this.cloneObject(obj[attr]);
+        }
+        return copy;
+    }
+    getActualDate(reload = false) {
+        reload = reload === undefined ? !UtilString.isValid(this.actualDate) : reload;
+        return new Promise((resolve, reject) => {
+            if (reload) {
+                this.commonService.getActualDate().subscribe((actualDate) => {
+                    this.actualDate = actualDate;
+                    resolve(actualDate);
+                }, (error) => {
+                    reject(error);
+                });
+            }
+            else {
+                resolve(this.actualDate);
+            }
+        });
+    }
+    get timeZoneBogota() {
+        return DateUtil.UTC_AMERICA_BOGOTA;
+    }
+    get utcBogota() {
+        return DateUtil.UTC_AMERICA_BOGOTA;
+    }
+}
+/** Static per page label */
+CommonListsComponent.LABEL_RECORDS_PER_PAGE = 'Registros por página';
+CommonListsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: CommonListsComponent, deps: [{ token: i1.CommonService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+CommonListsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: CommonListsComponent, selector: "app-administration", ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: CommonListsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-administration',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CommonService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { locale: [{
+                type: Inject,
+                args: [LOCALE_ID]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.lists.component.js","sourceRoot":"","sources":["../../../../../projects/ng-pli-commons/src/lib/components/common.lists.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OnInit, ChangeDetectorRef, Inject, LOCALE_ID, Component } from '@angular/core';\r\nimport { FormControl, FormGroup } from '@angular/forms';\r\nimport {\r\n\tUtilString,\r\n\tMoneda,\r\n\tTasaCambio,\r\n\tSelectItem,\r\n\tRubro,\r\n\tprimeLocaleEs,\r\n\tIdioma,\r\n\tProceso,\r\n\tEPermission,\r\n\tDateUtil\r\n} from 'ng-pli-util';\r\nimport { CommonService } from '../services/common.service';\r\nimport { FormUtil } from '../utils/form-util';\r\n\r\n@Component({\r\n    selector: 'app-administration',\r\n    template: ''\r\n})\r\nexport abstract class CommonListsComponent implements OnInit {\r\n\t/** Static per page label */\r\n\tstatic LABEL_RECORDS_PER_PAGE: string = 'Registros por página';\r\n\r\n\t/** */\r\n\t@Inject(LOCALE_ID) public locale: string;\r\n\t/** List of currency */\r\n\tlCurrency: Moneda[];\r\n\t/** List of currency */\r\n\tlSICurrency: SelectItem[];\r\n\t/** The subscription of the currencies */\r\n\r\n\t/** List of categories */\r\n\tlCategory: Rubro[];\r\n\t/** List of category */\r\n\tlSICategory: SelectItem[];\r\n\t/** The subscription of the categories */\r\n\r\n\t/** List of categories */\r\n\tlExchangeRate: TasaCambio[];\r\n\t/** List of exchange rate by ISO origin - destiny: USD-COP */\r\n\tlIsoExchangeRate: any;\r\n\t/** */\r\n\tprimeLocaleEs: any;\r\n\r\n\t/** List of language */\r\n\tlLanguage: Idioma[];\r\n\r\n\t/** List of Process */\r\n\tlProcess: Proceso[];\r\n\t/** List of process */\r\n\tlSIProcess: SelectItem[];\r\n\t/** getMoment moment instance */\r\n\tactualDate: any;\r\n\r\n\tconstructor(protected commonService: CommonService, protected cdRef: ChangeDetectorRef) {}\r\n\r\n\tngOnInit() {\r\n\t\tthis.onCurrencyInit();\r\n\t\tthis.primeLocaleEs = primeLocaleEs;\r\n\t}\r\n\r\n\t/** It prints the monCode */\r\n\tprivate printCurrencyCode(currency: Moneda): string {\r\n\t\treturn currency.monCodigoIso + '-' + currency.monMoneda;\r\n\t}\r\n\r\n\t/**\r\n\t * Init the info of currencies\r\n\t */\r\n\tonCurrencyInit() {\r\n\t\t// Subcription to the currency Subject\r\n\t\tthis.commonService.onCurrencyChanged().subscribe((lCurrency: Moneda[]) => {\r\n\t\t\tif (lCurrency) {\r\n\t\t\t\tthis.lCurrency = lCurrency;\r\n\t\t\t\tthis.lSICurrency = [];\r\n\t\t\t\tfor (let key in this.lCurrency) {\r\n\t\t\t\t\tlet currency: Moneda = this.lCurrency[key];\r\n\t\t\t\t\tthis.lSICurrency.push({\r\n\t\t\t\t\t\tlabel: this.printCurrencyCode(currency),\r\n\t\t\t\t\t\tvalue: currency\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t\t// Subcription to the category Subject\r\n\t\tthis.commonService.onCategoryChanged().subscribe((lCategory: Rubro[]) => {\r\n\t\t\tif (lCategory) {\r\n\t\t\t\tthis.lCategory = lCategory;\r\n\t\t\t\tthis.lSICategory = [];\r\n\t\t\t\tfor (let key in this.lCategory) {\r\n\t\t\t\t\tlet category: Rubro = this.lCategory[key];\r\n\t\t\t\t\tthis.lSICategory.push({\r\n\t\t\t\t\t\tlabel: category.rubRubro,\r\n\t\t\t\t\t\tvalue: category\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t\t// Subcription to the language Subject\r\n\t\tthis.commonService.onLanguageChanged().subscribe((lLanguage: Idioma[]) => {\r\n\t\t\tif (lLanguage) {\r\n\t\t\t\tthis.lLanguage = lLanguage;\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\t// Subcription to the category Subject\r\n\t\tthis.commonService.onExchangeRateChanged().subscribe((lExchangeRate: TasaCambio[]) => {\r\n\t\t\tif (lExchangeRate) {\r\n\t\t\t\tthis.lExchangeRate = lExchangeRate;\r\n\t\t\t\tthis.adjustmentIsoExchange();\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\t// Subcription to the category Subject\r\n\t\tthis.commonService.onProcessChanged().subscribe((lProcess: Proceso[]) => {\r\n\t\t\tif (lProcess) {\r\n\t\t\t\tthis.lProcess = lProcess;\r\n\t\t\t\tthis.lSIProcess = [];\r\n\t\t\t\tfor (let key in this.lProcess) {\r\n\t\t\t\t\tlet process: Proceso = this.lProcess[key];\r\n\t\t\t\t\tthis.lSIProcess.push({\r\n\t\t\t\t\t\tlabel: process.proNombre,\r\n\t\t\t\t\t\tvalue: process\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t\tthis.commonService.initValues();\r\n\t}\r\n\r\n\tadjustmentIsoExchange() {\r\n\t\t// let i = 0;\r\n\t\tlet lIsoExchage = [];\r\n\t\tfor (let key in this.lExchangeRate) {\r\n\t\t\tlet exchangeRate: TasaCambio = this.lExchangeRate[key];\r\n\t\t\tlet isoExchage = [];\r\n\t\t\tif (lIsoExchage[exchangeRate.monedaOrigen.monCodigoIso] !== undefined) {\r\n\t\t\t\tisoExchage = lIsoExchage[exchangeRate.monedaOrigen.monCodigoIso];\r\n\t\t\t}\r\n\t\t\tisoExchage[exchangeRate.monedaDestino.monCodigoIso] = exchangeRate;\r\n\t\t\tlIsoExchage[exchangeRate.monedaOrigen.monCodigoIso] = isoExchage;\r\n\t\t\t// console.log(i);\r\n\t\t\t// i++;\r\n\t\t}\r\n\t\tif (lIsoExchage) {\r\n\t\t\tthis.lIsoExchangeRate = [];\r\n\t\t\tfor (let key in lIsoExchage) {\r\n\t\t\t\tfor (let keyIso in lIsoExchage[key]) {\r\n\t\t\t\t\tlet exchangeRate: TasaCambio = lIsoExchage[key][keyIso];\r\n\t\t\t\t\tthis.lIsoExchangeRate[key + '-' + keyIso] = exchangeRate.tcamTasaCambio;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/** It returns a boolean if the control has any error */\r\n\thasErrors(formControl: FormControl): boolean {\r\n\t\treturn FormUtil.hasErrors(formControl);\r\n\t}\r\n\t/** It returns a boolean if the control has a specific error */\r\n\thasError(formControl: FormControl, error: string): boolean {\r\n\t\treturn FormUtil.hasError(formControl, error);\r\n\t}\r\n\r\n\t/** It validates if form is valid */\r\n\tisFormValid(formGroup: FormGroup): boolean {\r\n\t\tFormUtil.validateFormFields(formGroup);\r\n\t\tif (formGroup.valid) {\r\n\t\t\treturn true;\r\n\t\t} else {\r\n\t\t\tconsole.log('Invalid controls: ', FormUtil.getInvalidControls(formGroup));\r\n\t\t\treturn false;\r\n\t\t}\r\n\t}\r\n\r\n\tcopyMessage(val: string) {\r\n\t\tUtilString.copyMessage(val);\r\n\t}\r\n\r\n\t// ngOnDestroy() {\r\n\t//     try {\r\n\t//         this.commonService.currencyChanged.unsubscribe();\r\n\t//     } catch (error) {\r\n\t//         console.log(\"commonService.currencyChanged.unsubscribe\", error);\r\n\t//     }\r\n\t//     try {\r\n\t//         this.commonService.categoryChanged.unsubscribe();\r\n\t//     } catch (error) {\r\n\t//         console.log(\"commonService.categoryChanged.unsubscribe\", error);\r\n\t//     }\r\n\t//     try {\r\n\t//         this.commonService.exchangeRateChanged.unsubscribe();\r\n\t//     } catch (error) {\r\n\t//         console.log(\"commonService.exchangeRateChanged.unsubscribe\", error);\r\n\t//     }\r\n\t// }\r\n\t/** returns the permission according to x */\r\n\tp(x) {\r\n\t\treturn EPermission[x];\r\n\t}\r\n\r\n\tcloneObject(obj) {\r\n\t\tif (null == obj || 'object' != typeof obj) return obj;\r\n\t\tvar copy = obj.constructor();\r\n\t\tfor (var attr in obj) {\r\n\t\t\tif (obj.hasOwnProperty(attr)) copy[attr] = this.cloneObject(obj[attr]);\r\n\t\t}\r\n\t\treturn copy;\r\n\t}\r\n\r\n\tgetActualDate(reload: boolean = false): Promise<string> {\r\n\t\treload = reload === undefined ? !UtilString.isValid(this.actualDate) : reload;\r\n\t\treturn new Promise((resolve, reject) => {\r\n\t\t\tif (reload) {\r\n\t\t\t\tthis.commonService.getActualDate().subscribe(\r\n\t\t\t\t\t(actualDate: string) => {\r\n\t\t\t\t\t\tthis.actualDate = actualDate;\r\n\t\t\t\t\t\tresolve(actualDate);\r\n\t\t\t\t\t},\r\n\t\t\t\t\t(error) => {\r\n\t\t\t\t\t\treject(error);\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t} else {\r\n\t\t\t\tresolve(this.actualDate);\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tget timeZoneBogota(): string {\r\n\t\treturn DateUtil.UTC_AMERICA_BOGOTA;\r\n\t}\r\n\r\n\tget utcBogota(): string {\r\n\t\treturn DateUtil.UTC_AMERICA_BOGOTA;\r\n\t}\r\n}\r\n"]}

package/esm2020/lib/components/configuration-token/configuration-token-subject.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ConfigurationTokenSubjectService {
+    constructor() {
+        this.subjectConfigurationToken = new Subject();
+    }
+    getSubjectConfigurationTokens() {
+        return this.subjectConfigurationToken.asObservable();
+    }
+    setSubjectConfigurationTokens(tokens) {
+        return this.subjectConfigurationToken.next(tokens);
+    }
+}
+ConfigurationTokenSubjectService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ConfigurationTokenSubjectService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationTokenSubjectService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ConfigurationTokenSubjectService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ConfigurationTokenSubjectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJhdGlvbi10b2tlbi1zdWJqZWN0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1wbGktY29tbW9ucy9zcmMvbGliL2NvbXBvbmVudHMvY29uZmlndXJhdGlvbi10b2tlbi9jb25maWd1cmF0aW9uLXRva2VuLXN1YmplY3Quc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxPQUFPLEVBQWMsTUFBTSxNQUFNLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxnQ0FBZ0M7SUFJM0M7UUFGUSw4QkFBeUIsR0FBRyxJQUFJLE9BQU8sRUFBUyxDQUFDO0lBRXpDLENBQUM7SUFFakIsNkJBQTZCO1FBQzNCLE9BQU8sSUFBSSxDQUFDLHlCQUF5QixDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3ZELENBQUM7SUFFRCw2QkFBNkIsQ0FBQyxNQUFhO1FBQ3pDLE9BQU8sSUFBSSxDQUFDLHlCQUF5QixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNyRCxDQUFDOzs2SEFaVSxnQ0FBZ0M7aUlBQWhDLGdDQUFnQyxjQUYvQixNQUFNOzJGQUVQLGdDQUFnQztrQkFINUMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFN1YmplY3QsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCcsXHJcbiB9KVxyXG5leHBvcnQgY2xhc3MgQ29uZmlndXJhdGlvblRva2VuU3ViamVjdFNlcnZpY2Uge1xyXG5cclxuICBwcml2YXRlIHN1YmplY3RDb25maWd1cmF0aW9uVG9rZW4gPSBuZXcgU3ViamVjdDxhbnlbXT4oKTtcclxuXHJcbiAgY29uc3RydWN0b3IoKSB7IH1cclxuXHJcbiAgZ2V0U3ViamVjdENvbmZpZ3VyYXRpb25Ub2tlbnMoKTogT2JzZXJ2YWJsZTxhbnlbXT4ge1xyXG4gICAgcmV0dXJuIHRoaXMuc3ViamVjdENvbmZpZ3VyYXRpb25Ub2tlbi5hc09ic2VydmFibGUoKTtcclxuICB9XHJcblxyXG4gIHNldFN1YmplY3RDb25maWd1cmF0aW9uVG9rZW5zKHRva2VuczogYW55W10pIHtcclxuICAgIHJldHVybiB0aGlzLnN1YmplY3RDb25maWd1cmF0aW9uVG9rZW4ubmV4dCh0b2tlbnMpO1xyXG4gIH1cclxuICBcclxufVxyXG4iXX0=