taxtank-core 0.33.115 → 0.33.116

package/esm2022/src/lib/services/report/property/property-transaction-report.service.mjs

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { CHART_ACCOUNTS_CATEGORIES } from '../../../models';
+import { PropertyReportItemCollection, PropertyReportItemDepreciationCollection, PropertyReportItemTransactionCollection, TransactionCollection, } from '../../../collections';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../http";
+/**
+ * Service to handle Property transactions report items data (get income / expense report items, e.t.c.)
+ */
+export class PropertyTransactionReportService {
+    constructor(propertyService, transactionService, depreciationService, chartAccountsService) {
+        this.propertyService = propertyService;
+        this.transactionService = transactionService;
+        this.depreciationService = depreciationService;
+        this.chartAccountsService = chartAccountsService;
+    }
+    /**
+     * Get collection of report items based on transactions & depreciations
+     */
+    get() {
+        return combineLatest([
+            this.propertyService.get(),
+            this.getTransactions(),
+            this.getDepreciations(),
+            this.chartAccountsService.get()
+        ]).pipe(map(([properties, transactions, depreciations, chartAccounts]) => {
+            this.properties = properties;
+            this.transactions = transactions.filter(transaction => !transaction.chartAccounts.isDepreciation());
+            this.depreciations = depreciations;
+            this.chartAccounts = chartAccounts;
+            return this.create(this.transactions, depreciations, properties, chartAccounts);
+        }));
+    }
+    filter(filterForm) {
+        return this.create(filterForm.filter(this.transactions), filterForm.filter(this.depreciations), this.properties, this.chartAccounts);
+    }
+    create(transactions, depreciations, properties, chartAccounts) {
+        return new PropertyReportItemCollection([
+            ...new PropertyReportItemTransactionCollection(transactions, properties, chartAccounts).items,
+            ...new PropertyReportItemDepreciationCollection(depreciations, properties, chartAccounts).items,
+        ]).sortBy('subCode', 'asc').groupBy('propertyId');
+    }
+    /**
+     * Get collection of property transactions
+     */
+    getTransactions() {
+        // @TODO TT-4886
+        return this.transactionService.getWithoutTaxFreeProperty().pipe(map((transactions) => new TransactionCollection(transactions)
+            .getByChartAccountsCategories(CHART_ACCOUNTS_CATEGORIES.property)
+            .filter(transaction => transaction.claimPercent > 0)));
+    }
+    /**
+     * Get list of asset & capital property depreciations
+     */
+    getDepreciations() {
+        return this.depreciationService.get().pipe(map((depreciations) => depreciations.getByChartAccountsCategories(CHART_ACCOUNTS_CATEGORIES.property)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PropertyTransactionReportService, deps: [{ token: i1.PropertyService }, { token: i1.TransactionService }, { token: i1.DepreciationService }, { token: i1.ChartAccountsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PropertyTransactionReportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PropertyTransactionReportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.PropertyService }, { type: i1.TransactionService }, { type: i1.DepreciationService }, { type: i1.ChartAccountsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-transaction-report.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/report/property/property-transaction-report.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ChartAccountsService, DepreciationService, PropertyService, TransactionService, } from '../../http';\nimport { Observable, combineLatest } from 'rxjs';\nimport { CHART_ACCOUNTS_CATEGORIES, Transaction } from '../../../models';\nimport {\n  ChartAccountsCollection,\n  CollectionDictionary,\n  DepreciationCollection,\n  PropertyCollection,\n  PropertyReportItemCollection,\n  PropertyReportItemDepreciationCollection,\n  PropertyReportItemTransactionCollection,\n  TransactionCollection,\n} from '../../../collections';\nimport { map } from 'rxjs/operators';\nimport { TransactionBaseFilterForm } from '../../../forms';\n\n/**\n * Service to handle Property transactions report items data (get income / expense report items, e.t.c.)\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class PropertyTransactionReportService {\n  properties: PropertyCollection;\n  transactions: TransactionCollection;\n  depreciations: DepreciationCollection;\n  chartAccounts: ChartAccountsCollection;\n\n  constructor(\n    private propertyService: PropertyService,\n    private transactionService: TransactionService,\n    private depreciationService: DepreciationService,\n    private chartAccountsService: ChartAccountsService\n  ) {\n  }\n\n  /**\n   * Get collection of report items based on transactions & depreciations\n   */\n  get(): Observable<CollectionDictionary<PropertyReportItemCollection>> {\n    return combineLatest([\n      this.propertyService.get() as Observable<PropertyCollection>,\n      this.getTransactions() as Observable<TransactionCollection>,\n      this.getDepreciations() as Observable<DepreciationCollection>,\n      this.chartAccountsService.get() as Observable<ChartAccountsCollection>\n    ]).pipe(\n      map(([properties, transactions, depreciations, chartAccounts]) => {\n        this.properties = properties;\n        this.transactions = transactions.filter(transaction => !transaction.chartAccounts.isDepreciation());\n        this.depreciations = depreciations;\n        this.chartAccounts = chartAccounts;\n        return this.create(this.transactions, depreciations, properties, chartAccounts);\n      })\n    );\n  }\n\n  filter(filterForm: TransactionBaseFilterForm): CollectionDictionary<PropertyReportItemCollection> {\n    return this.create(\n      filterForm.filter(this.transactions),\n      filterForm.filter(this.depreciations),\n      this.properties,\n      this.chartAccounts\n    );\n  }\n\n  private create(\n    transactions: TransactionCollection,\n    depreciations: DepreciationCollection,\n    properties: PropertyCollection,\n    chartAccounts: ChartAccountsCollection\n  ): CollectionDictionary<PropertyReportItemCollection> {\n    return new PropertyReportItemCollection([\n      ...new PropertyReportItemTransactionCollection(transactions, properties, chartAccounts).items,\n      ...new PropertyReportItemDepreciationCollection(depreciations, properties, chartAccounts).items,\n    ]).sortBy('subCode', 'asc').groupBy('propertyId');\n  }\n\n  /**\n   * Get collection of property transactions\n   */\n  private getTransactions(): Observable<TransactionCollection> {\n    // @TODO TT-4886\n    return this.transactionService.getWithoutTaxFreeProperty().pipe(\n      map((transactions: Transaction[]) => new TransactionCollection(transactions)\n        .getByChartAccountsCategories(CHART_ACCOUNTS_CATEGORIES.property)\n        .filter(transaction => transaction.claimPercent > 0)\n      )\n    );\n  }\n\n  /**\n   * Get list of asset & capital property depreciations\n   */\n  private getDepreciations(): Observable<DepreciationCollection> {\n    return this.depreciationService.get().pipe(\n      map((depreciations: DepreciationCollection) => depreciations.getByChartAccountsCategories(CHART_ACCOUNTS_CATEGORIES.property))\n    );\n  }\n}\n"]}

package/esm2022/src/lib/services/toast/index.mjs

@@ -0,0 +1,2 @@
+export * from './toast.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvdG9hc3QvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdG9hc3Quc2VydmljZSc7XG4iXX0=

package/esm2022/src/lib/services/toast/toast.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { Toast } from '../../models/toast/toast';
+import { plainToClass } from 'class-transformer';
+import { ToastTypeEnum } from '../../models/toast/toast-type.enum';
+import * as i0 from "@angular/core";
+/**
+ * popup notifications service (toast, snackbar).
+ */
+export class ToastService {
+    constructor() {
+        this.toast$ = new ReplaySubject(1);
+    }
+    get() {
+        return this.toast$.asObservable();
+    }
+    add(toast) {
+        // set date to prevent closing of equal toasts (extra case)
+        toast.date = new Date(),
+            this.toast$.next(toast);
+    }
+    success(message) {
+        this.add(plainToClass(Toast, {
+            type: ToastTypeEnum.SUCCESS,
+            title: 'Success!',
+            message,
+        }));
+    }
+    warning(message) {
+        this.add(plainToClass(Toast, {
+            type: ToastTypeEnum.WARNING,
+            title: 'Notification!',
+            message,
+        }));
+    }
+    error(message) {
+        this.add(plainToClass(Toast, {
+            type: ToastTypeEnum.ERROR,
+            title: 'Error!',
+            message,
+        }));
+    }
+    info(message) {
+        this.add(plainToClass(Toast, {
+            type: ToastTypeEnum.INFO,
+            title: 'Information',
+            message,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToastService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/user/index.mjs

@@ -0,0 +1,2 @@
+export * from './user-switcher.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvdXNlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi91c2VyLXN3aXRjaGVyLnNlcnZpY2UnO1xuIl19

package/esm2022/src/lib/services/user/user-switcher.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+const KEY = '_switch_user';
+/**
+ * provides user management to managers (users with ROLE_ACCOUNTANT for now, more in future)
+ */
+export class UserSwitcherService {
+    /**
+     * get switched username
+     */
+    get() {
+        return localStorage[KEY];
+    }
+    /**
+     * switch to user (username should be used for correct work of backend)
+     */
+    set(username) {
+        localStorage[KEY] = username;
+        window.location.replace('/client/dashboard');
+    }
+    /**
+     * go back to original user
+     */
+    reset() {
+        localStorage.removeItem(KEY);
+        window.location.replace('/firm/dashboard');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UserSwitcherService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UserSwitcherService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UserSwitcherService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1zd2l0Y2hlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL3VzZXIvdXNlci1zd2l0Y2hlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTNDLE1BQU0sR0FBRyxHQUFHLGNBQWMsQ0FBQztBQUUzQjs7R0FFRztBQUlILE1BQU0sT0FBTyxtQkFBbUI7SUFDOUI7O09BRUc7SUFDSCxHQUFHO1FBQ0QsT0FBTyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVEOztPQUVHO0lBQ0gsR0FBRyxDQUFDLFFBQWdCO1FBQ2xCLFlBQVksQ0FBQyxHQUFHLENBQUMsR0FBRyxRQUFRLENBQUM7UUFDN0IsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxLQUFLO1FBQ0gsWUFBWSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUM3QixNQUFNLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQzdDLENBQUM7K0dBdEJVLG1CQUFtQjttSEFBbkIsbUJBQW1CLGNBRmxCLE1BQU07OzRGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmNvbnN0IEtFWSA9ICdfc3dpdGNoX3VzZXInO1xuXG4vKipcbiAqIHByb3ZpZGVzIHVzZXIgbWFuYWdlbWVudCB0byBtYW5hZ2VycyAodXNlcnMgd2l0aCBST0xFX0FDQ09VTlRBTlQgZm9yIG5vdywgbW9yZSBpbiBmdXR1cmUpXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFVzZXJTd2l0Y2hlclNlcnZpY2Uge1xuICAvKipcbiAgICogZ2V0IHN3aXRjaGVkIHVzZXJuYW1lXG4gICAqL1xuICBnZXQoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gbG9jYWxTdG9yYWdlW0tFWV07XG4gIH1cblxuICAvKipcbiAgICogc3dpdGNoIHRvIHVzZXIgKHVzZXJuYW1lIHNob3VsZCBiZSB1c2VkIGZvciBjb3JyZWN0IHdvcmsgb2YgYmFja2VuZClcbiAgICovXG4gIHNldCh1c2VybmFtZTogc3RyaW5nKTogdm9pZCB7XG4gICAgbG9jYWxTdG9yYWdlW0tFWV0gPSB1c2VybmFtZTtcbiAgICB3aW5kb3cubG9jYXRpb24ucmVwbGFjZSgnL2NsaWVudC9kYXNoYm9hcmQnKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBnbyBiYWNrIHRvIG9yaWdpbmFsIHVzZXJcbiAgICovXG4gIHJlc2V0KCk6IHZvaWQge1xuICAgIGxvY2FsU3RvcmFnZS5yZW1vdmVJdGVtKEtFWSk7XG4gICAgd2luZG93LmxvY2F0aW9uLnJlcGxhY2UoJy9maXJtL2Rhc2hib2FyZCcpO1xuICB9XG59XG4iXX0=

package/esm2022/src/lib/services/xlsx/index.mjs

@@ -0,0 +1,2 @@
+export * from './xlsx.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMveGxzeC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi94bHN4LnNlcnZpY2UnO1xuIl19

package/esm2022/src/lib/services/xlsx/xlsx.service.mjs

@@ -0,0 +1,102 @@
+import { Injectable } from '@angular/core';
+import * as xlsx from 'xlsx';
+import * as FileSaver from 'file-saver';
+import * as i0 from "@angular/core";
+const EXCEL_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';
+/**
+ * Service to work with XLSX (generate, download, e.t.c.)
+ */
+export class XlsxService {
+    constructor() {
+        this.getFileName = (name) => {
+            const sheetName = name || 'ExportResult';
+            const fileName = `${sheetName}`;
+            return {
+                sheetName,
+                fileName
+            };
+        };
+    }
+    /**
+     * Export file form provided HTML tables
+     */
+    exportTables(tables, title, fileName) {
+        const excelFile = this.generateFromTables(tables, title);
+        const data = new Blob([excelFile], {
+            type: EXCEL_TYPE
+        });
+        FileSaver.saveAs(data, `${fileName}.xlsx`);
+    }
+    generateFromTables(tables, title) {
+        // create new workbook
+        const workbook = xlsx.utils.book_new();
+        // create empty worksheet
+        const worksheet = {
+            SheetNames: [],
+            Sheets: {}
+        };
+        tables.forEach((data) => {
+            // add caption for the current table
+            xlsx.utils.sheet_add_aoa(worksheet, [[data.caption?.innerText]], { origin: -1 });
+            // Prepare to add table data to the worksheet, processing each cell
+            const rows = Array.from(data.rows)
+                .map((row) => Array.from(row.cells).map(cell => this.htmlToXlsCell(cell)));
+            // Add the processed table data to the worksheet
+            xlsx.utils.sheet_add_aoa(worksheet, rows, { origin: -1 });
+            // set empty row after current table
+            xlsx.utils.sheet_add_aoa(worksheet, [], { origin: -1 });
+        });
+        xlsx.utils.book_append_sheet(workbook, worksheet);
+        return xlsx.write(workbook, { bookType: 'xlsx', type: 'array' });
+    }
+    htmlToXlsCell(cell) {
+        const cellValue = cell.innerText.trim();
+        // regex to check currency value
+        return /^-?\$/.test(cellValue) ? this.currencyToNumber(cellValue) : cellValue;
+    }
+    /**
+     * function which reconverts values from customCurrencyPipe
+     * @param cellValue - string with $ and possibly comma.  $123,123.03
+     * @returns value without $ and comma. like 123123.03
+     */
+    currencyToNumber(cellValue) {
+        // remove dollar sign and comma
+        cellValue = cellValue.replace(/[$,]/g, '');
+        return parseFloat(cellValue);
+    }
+    /**
+     * @TODO vik/artem work with ExportDataTable instead of ExportableCollection
+     * @TODO vik/artem why so much code? here is 6 rows solution https://stackoverflow.com/questions/64939994/how-to-export-array-of-objects-to-an-excel-in-angular-8
+     */
+    exportArrayToExcel(exportableCollection, name, params) {
+        const workbook = xlsx.utils.book_new();
+        // create empty worksheet
+        const worksheet = {
+            SheetNames: [],
+            Sheets: {}
+        };
+        const exportData = exportableCollection.export(params);
+        const exportAoa = exportableCollection.getBodyAoa(exportData);
+        const { sheetName, fileName } = this.getFileName(name);
+        xlsx.utils.sheet_add_aoa(worksheet, [exportData.header], { origin: -1 });
+        // add table table data to the worksheet
+        xlsx.utils.sheet_add_aoa(worksheet, exportAoa, { origin: -1 });
+        // set empty row after current table
+        xlsx.utils.sheet_add_aoa(worksheet, [], { origin: -1 });
+        xlsx.utils.book_append_sheet(workbook, worksheet);
+        const excelFile = xlsx.write(workbook, { bookType: 'xlsx', type: 'array' });
+        const data = new Blob([excelFile], {
+            type: EXCEL_TYPE
+        });
+        FileSaver.saveAs(data, `${fileName}.xlsx`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: XlsxService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: XlsxService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: XlsxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xlsx.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/xlsx/xlsx.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport * as xlsx from 'xlsx';\nimport * as FileSaver from 'file-saver';\nimport { ExportableCollection } from '../../collections';\nimport { ExportDataTable } from '../../models/export/export-data-table';\n\nconst EXCEL_TYPE: string = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8'\n\n@Injectable({\n  providedIn: 'root'\n})\n\n/**\n * Service to work with XLSX (generate, download, e.t.c.)\n */\nexport class XlsxService {\n  /**\n   * Export file form provided HTML tables\n   */\n  exportTables(tables: NodeListOf<HTMLTableElement>, title: string, fileName: string): void {\n    const excelFile: BlobPart = this.generateFromTables(tables, title);\n    const data: Blob = new Blob([excelFile], {\n      type: EXCEL_TYPE\n    });\n\n    FileSaver.saveAs(data, `${fileName}.xlsx`);\n  }\n\n  private generateFromTables(tables: NodeListOf<HTMLTableElement>, title?: string): BlobPart {\n    // create new workbook\n    const workbook: xlsx.WorkBook = xlsx.utils.book_new();\n    // create empty worksheet\n    const worksheet: xlsx.WorkSheet = {\n      SheetNames: [],\n      Sheets: {}\n    };\n\n    tables.forEach((data: HTMLTableElement) => {\n      // add caption for the current table\n      xlsx.utils.sheet_add_aoa(worksheet, [[data.caption?.innerText]], { origin: -1 });\n      // Prepare to add table data to the worksheet, processing each cell\n      const rows = Array.from(data.rows)\n        .map((row: HTMLTableRowElement) => Array.from(row.cells).map(cell => this.htmlToXlsCell(cell)));\n      // Add the processed table data to the worksheet\n      xlsx.utils.sheet_add_aoa(worksheet, rows, { origin: -1 });\n      // set empty row after current table\n      xlsx.utils.sheet_add_aoa(worksheet, [], { origin: -1 });\n    });\n\n    xlsx.utils.book_append_sheet(workbook, worksheet);\n    return xlsx.write(workbook, { bookType: 'xlsx', type: 'array' });\n  }\n\n  htmlToXlsCell(cell: HTMLTableCellElement): string | number {\n    const cellValue = cell.innerText.trim();\n    // regex to check currency value\n    return /^-?\\$/.test(cellValue) ? this.currencyToNumber(cellValue) : cellValue;\n  }\n\n  /**\n   * function which reconverts values from customCurrencyPipe\n   * @param cellValue - string with $ and possibly comma.  $123,123.03\n   * @returns value without $ and comma. like 123123.03\n   */\n  currencyToNumber(cellValue: string): number {\n    // remove dollar sign and comma\n    cellValue = cellValue.replace(/[$,]/g, '');\n\n    return parseFloat(cellValue);\n  }\n\n  getFileName = (name: string) => {\n    const sheetName = name || 'ExportResult';\n    const fileName = `${sheetName}`;\n    return {\n      sheetName,\n      fileName\n    };\n  };\n\n  /**\n   * @TODO vik/artem work with ExportDataTable instead of ExportableCollection\n   * @TODO vik/artem why so much code? here is 6 rows solution https://stackoverflow.com/questions/64939994/how-to-export-array-of-objects-to-an-excel-in-angular-8\n   */\n  exportArrayToExcel(exportableCollection: ExportableCollection<any>, name?: string, params? : any) {\n    const workbook: xlsx.WorkBook = xlsx.utils.book_new();\n    // create empty worksheet\n    const worksheet: xlsx.WorkSheet = {\n      SheetNames: [],\n      Sheets: {}\n    };\n\n    const exportData: ExportDataTable = exportableCollection.export(params)\n    const exportAoa = exportableCollection.getBodyAoa(exportData);\n    const { sheetName, fileName } = this.getFileName(name);\n\n    xlsx.utils.sheet_add_aoa(worksheet, [exportData.header], { origin: -1 });\n    // add table table data to the worksheet\n    xlsx.utils.sheet_add_aoa(worksheet, exportAoa, { origin: -1 });\n    // set empty row after current table\n    xlsx.utils.sheet_add_aoa(worksheet, [], { origin: -1 });\n\n    xlsx.utils.book_append_sheet(workbook, worksheet);\n    const excelFile: BlobPart = xlsx.write(workbook, { bookType: 'xlsx', type: 'array' });\n\n    const data: Blob = new Blob([excelFile], {\n      type: EXCEL_TYPE\n    });\n    FileSaver.saveAs(data, `${fileName}.xlsx`);\n  }\n}\n"]}

package/esm2022/src/lib/validators/at-least-one-enabled.validator.mjs

@@ -0,0 +1,9 @@
+/**
+ * Validator check if at least one control in formArray is enabled
+ */
+export function atLeastOneEnabledValidator(arrayName) {
+    return (formGroup) => formGroup.get(arrayName).controls.find((control) => control.enabled)
+        ? null
+        : { arrayControlsDisabled: true };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXQtbGVhc3Qtb25lLWVuYWJsZWQudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3ZhbGlkYXRvcnMvYXQtbGVhc3Qtb25lLWVuYWJsZWQudmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLDBCQUEwQixDQUFDLFNBQWlCO0lBQzFELE9BQU8sQ0FBQyxTQUEyQixFQUFvQixFQUFFLENBQUUsU0FBUyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQXNCLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLE9BQXdCLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUM7UUFDbkssQ0FBQyxDQUFDLElBQUk7UUFDTixDQUFDLENBQUMsRUFBQyxxQkFBcUIsRUFBRSxJQUFJLEVBQUMsQ0FBQTtBQUNuQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sLCBVbnR5cGVkRm9ybUFycmF5LCBVbnR5cGVkRm9ybUdyb3VwLCBWYWxpZGF0aW9uRXJyb3JzLCBWYWxpZGF0b3JGbiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuLyoqXG4gKiBWYWxpZGF0b3IgY2hlY2sgaWYgYXQgbGVhc3Qgb25lIGNvbnRyb2wgaW4gZm9ybUFycmF5IGlzIGVuYWJsZWRcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGF0TGVhc3RPbmVFbmFibGVkVmFsaWRhdG9yKGFycmF5TmFtZTogc3RyaW5nKTogVmFsaWRhdG9yRm4ge1xuICByZXR1cm4gKGZvcm1Hcm91cDogVW50eXBlZEZvcm1Hcm91cCk6IFZhbGlkYXRpb25FcnJvcnMgPT4gKGZvcm1Hcm91cC5nZXQoYXJyYXlOYW1lKSBhcyBVbnR5cGVkRm9ybUFycmF5KS5jb250cm9scy5maW5kKChjb250cm9sOiBBYnN0cmFjdENvbnRyb2wpID0+IGNvbnRyb2wuZW5hYmxlZClcbiAgICA/IG51bGxcbiAgICA6IHthcnJheUNvbnRyb2xzRGlzYWJsZWQ6IHRydWV9XG59XG4iXX0=

package/esm2022/src/lib/validators/at-least-one.validator.mjs

@@ -0,0 +1,9 @@
+/**
+ * Check if at least one form field is true, otherwise form is invalid.
+ * Use with groups of boolean form controls (checkbox, toggle, etc.)
+ */
+export function atLeastOneCheckedValidator() {
+    return (formGroup) => Object.values(formGroup.controls)
+        .find((control) => control.value) ? null : { nothingChecked: true };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXQtbGVhc3Qtb25lLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi92YWxpZGF0b3JzL2F0LWxlYXN0LW9uZS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLDBCQUEwQjtJQUN4QyxPQUFPLENBQUMsU0FBMkIsRUFBb0IsRUFBRSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQztTQUN4RixJQUFJLENBQUMsQ0FBQyxPQUEyQixFQUFXLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBQyxjQUFjLEVBQUUsSUFBSSxFQUFDLENBQUE7QUFDbEcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFVudHlwZWRGb3JtQ29udHJvbCwgVW50eXBlZEZvcm1Hcm91cCwgVmFsaWRhdGlvbkVycm9ycywgVmFsaWRhdG9yRm4gfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbi8qKlxuICogQ2hlY2sgaWYgYXQgbGVhc3Qgb25lIGZvcm0gZmllbGQgaXMgdHJ1ZSwgb3RoZXJ3aXNlIGZvcm0gaXMgaW52YWxpZC5cbiAqIFVzZSB3aXRoIGdyb3VwcyBvZiBib29sZWFuIGZvcm0gY29udHJvbHMgKGNoZWNrYm94LCB0b2dnbGUsIGV0Yy4pXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhdExlYXN0T25lQ2hlY2tlZFZhbGlkYXRvcigpOiBWYWxpZGF0b3JGbiB7XG4gIHJldHVybiAoZm9ybUdyb3VwOiBVbnR5cGVkRm9ybUdyb3VwKTogVmFsaWRhdGlvbkVycm9ycyA9PiBPYmplY3QudmFsdWVzKGZvcm1Hcm91cC5jb250cm9scylcbiAgICAuZmluZCgoY29udHJvbDogVW50eXBlZEZvcm1Db250cm9sKTogYm9vbGVhbiA9PiBjb250cm9sLnZhbHVlKSA/IG51bGwgOiB7bm90aGluZ0NoZWNrZWQ6IHRydWV9XG59XG4iXX0=

package/esm2022/src/lib/validators/autocomplete.validator.mjs

@@ -0,0 +1,8 @@
+/**
+ * Validation function for autocomplete fields. Checks that the user should select a value from a list rather than type in input field
+ * @TODO Alex: create class AppValidators with static methods and move there all custom validators (line Angular Validators)
+ */
+export function autocompleteValidator() {
+    return (control) => (!control.value || (typeof control.value === 'object')) ? null : { notFromList: true };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi92YWxpZGF0b3JzL2F1dG9jb21wbGV0ZS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQjtJQUNuQyxPQUFPLENBQUMsT0FBMkIsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLElBQUksQ0FBQyxPQUFPLE9BQU8sQ0FBQyxLQUFLLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFDLFdBQVcsRUFBRSxJQUFJLEVBQUMsQ0FBQztBQUMvSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVW50eXBlZEZvcm1Db250cm9sLCBWYWxpZGF0b3JGbiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuLyoqXG4gKiBWYWxpZGF0aW9uIGZ1bmN0aW9uIGZvciBhdXRvY29tcGxldGUgZmllbGRzLiBDaGVja3MgdGhhdCB0aGUgdXNlciBzaG91bGQgc2VsZWN0IGEgdmFsdWUgZnJvbSBhIGxpc3QgcmF0aGVyIHRoYW4gdHlwZSBpbiBpbnB1dCBmaWVsZFxuICogQFRPRE8gQWxleDogY3JlYXRlIGNsYXNzIEFwcFZhbGlkYXRvcnMgd2l0aCBzdGF0aWMgbWV0aG9kcyBhbmQgbW92ZSB0aGVyZSBhbGwgY3VzdG9tIHZhbGlkYXRvcnMgKGxpbmUgQW5ndWxhciBWYWxpZGF0b3JzKVxuICovXG5leHBvcnQgZnVuY3Rpb24gYXV0b2NvbXBsZXRlVmFsaWRhdG9yKCk6IFZhbGlkYXRvckZuIHtcbiAgcmV0dXJuIChjb250cm9sOiBVbnR5cGVkRm9ybUNvbnRyb2wpID0+ICghY29udHJvbC52YWx1ZSB8fCAodHlwZW9mIGNvbnRyb2wudmFsdWUgPT09ICdvYmplY3QnKSkgPyBudWxsIDoge25vdEZyb21MaXN0OiB0cnVlfTtcbn1cbiJdfQ==

package/esm2022/src/lib/validators/conditional.validator.mjs

@@ -0,0 +1,26 @@
+import { distinctUntilChanged } from 'rxjs/operators';
+export function conditionalValidator(condition, validator) {
+    return function (control) {
+        revalidateOnChanges(control);
+        if (control && control.parent) {
+            if (condition(control.parent)) {
+                return validator(control);
+            }
+        }
+        return null;
+    };
+}
+/**
+ * Conditional validator depends on other fields and should be updated on each form value change
+ */
+function revalidateOnChanges(control) {
+    if (control && control.parent && !control['_revalidateOnChanges']) {
+        control['_revalidateOnChanges'] = true;
+        control.parent.valueChanges.pipe(distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)))
+            .subscribe(() => {
+            control.updateValueAndValidity({ emitEvent: false });
+        });
+    }
+    return;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/validators/current-fin-year.validator.mjs

@@ -0,0 +1,15 @@
+import { FinancialYear } from '../models';
+/**
+ * Validation function, that checks If provided date is within a current financial year
+ */
+export function currentFinYearValidator() {
+    const currentFinYear = new FinancialYear();
+    return (control) => {
+        const date = new Date(control.value);
+        if (!control.value || date >= currentFinYear.startDate && date <= currentFinYear.endDate) {
+            return null;
+        }
+        return { notCurrentFinYear: true };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVudC1maW4teWVhci52YWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvdmFsaWRhdG9ycy9jdXJyZW50LWZpbi15ZWFyLnZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRTFDOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QjtJQUNyQyxNQUFNLGNBQWMsR0FBa0IsSUFBSSxhQUFhLEVBQUUsQ0FBQztJQUUxRCxPQUFPLENBQUMsT0FBd0IsRUFBb0IsRUFBRTtRQUNwRCxNQUFNLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLElBQUksSUFBSSxJQUFJLGNBQWMsQ0FBQyxTQUFTLElBQUksSUFBSSxJQUFJLGNBQWMsQ0FBQyxPQUFPLEVBQUU7WUFDeEYsT0FBTyxJQUFJLENBQUM7U0FDYjtRQUVELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNyQyxDQUFDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sLCBWYWxpZGF0aW9uRXJyb3JzLCBWYWxpZGF0b3JGbiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB7IEZpbmFuY2lhbFllYXIgfSBmcm9tICcuLi9tb2RlbHMnO1xuXG4vKipcbiAqIFZhbGlkYXRpb24gZnVuY3Rpb24sIHRoYXQgY2hlY2tzIElmIHByb3ZpZGVkIGRhdGUgaXMgd2l0aGluIGEgY3VycmVudCBmaW5hbmNpYWwgeWVhclxuICovXG5leHBvcnQgZnVuY3Rpb24gY3VycmVudEZpblllYXJWYWxpZGF0b3IoKTogVmFsaWRhdG9yRm4ge1xuICBjb25zdCBjdXJyZW50RmluWWVhcjogRmluYW5jaWFsWWVhciA9IG5ldyBGaW5hbmNpYWxZZWFyKCk7XG5cbiAgcmV0dXJuIChjb250cm9sOiBBYnN0cmFjdENvbnRyb2wpOiBWYWxpZGF0aW9uRXJyb3JzID0+IHtcbiAgICBjb25zdCBkYXRlID0gbmV3IERhdGUoY29udHJvbC52YWx1ZSk7XG4gICAgaWYgKCFjb250cm9sLnZhbHVlIHx8IGRhdGUgPj0gY3VycmVudEZpblllYXIuc3RhcnREYXRlICYmIGRhdGUgPD0gY3VycmVudEZpblllYXIuZW5kRGF0ZSkge1xuICAgICAgcmV0dXJuIG51bGw7XG4gICAgfVxuXG4gICAgcmV0dXJuIHsgbm90Q3VycmVudEZpblllYXI6IHRydWUgfTtcbiAgfTtcbn1cbiJdfQ==

package/esm2022/src/lib/validators/date/max-date.validator.mjs

@@ -0,0 +1,17 @@
+import { DatePipe } from '@angular/common';
+/**
+ * Validation function, that checks If date form value is more than provided date
+ */
+export function maxDateValidator(date, message = `The date should not be after ${new DatePipe('en-US').transform(date)}`) {
+    return (control) => {
+        if (!control.value) {
+            return null;
+        }
+        // form control value can be as a Moment object - we wrap it in "new Date()" to work with it like with JS Date
+        if (new Date(control.value) <= new Date(date)) {
+            return null;
+        }
+        return { minDate: message };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF4LWRhdGUudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3ZhbGlkYXRvcnMvZGF0ZS9tYXgtZGF0ZS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTNDOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixJQUFVLEVBQ1YsVUFBa0IsZ0NBQWdDLElBQUksUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRTtJQUV6RixPQUFPLENBQUMsT0FBd0IsRUFBb0IsRUFBRTtRQUNwRCxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRTtZQUNsQixPQUFPLElBQUksQ0FBQztTQUNiO1FBRUQsOEdBQThHO1FBQzlHLElBQUksSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQzdDLE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFFRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQzlCLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBYnN0cmFjdENvbnRyb2wsIFZhbGlkYXRpb25FcnJvcnMsIFZhbGlkYXRvckZuIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgRGF0ZVBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG4vKipcbiAqIFZhbGlkYXRpb24gZnVuY3Rpb24sIHRoYXQgY2hlY2tzIElmIGRhdGUgZm9ybSB2YWx1ZSBpcyBtb3JlIHRoYW4gcHJvdmlkZWQgZGF0ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gbWF4RGF0ZVZhbGlkYXRvcihcbiAgZGF0ZTogRGF0ZSxcbiAgbWVzc2FnZTogc3RyaW5nID0gYFRoZSBkYXRlIHNob3VsZCBub3QgYmUgYWZ0ZXIgJHtuZXcgRGF0ZVBpcGUoJ2VuLVVTJykudHJhbnNmb3JtKGRhdGUpfWBcbik6IFZhbGlkYXRvckZuIHtcbiAgcmV0dXJuIChjb250cm9sOiBBYnN0cmFjdENvbnRyb2wpOiBWYWxpZGF0aW9uRXJyb3JzID0+IHtcbiAgICBpZiAoIWNvbnRyb2wudmFsdWUpIHtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cblxuICAgIC8vIGZvcm0gY29udHJvbCB2YWx1ZSBjYW4gYmUgYXMgYSBNb21lbnQgb2JqZWN0IC0gd2Ugd3JhcCBpdCBpbiBcIm5ldyBEYXRlKClcIiB0byB3b3JrIHdpdGggaXQgbGlrZSB3aXRoIEpTIERhdGVcbiAgICBpZiAobmV3IERhdGUoY29udHJvbC52YWx1ZSkgPD0gbmV3IERhdGUoZGF0ZSkpIHtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cblxuICAgIHJldHVybiB7IG1pbkRhdGU6IG1lc3NhZ2UgfTtcbiAgfTtcbn1cbiJdfQ==

package/esm2022/src/lib/validators/date/min-date.validator.mjs

@@ -0,0 +1,17 @@
+import { DatePipe } from '@angular/common';
+/**
+ * Validation function, that checks If date form value is more than provided date
+ */
+export function minDateValidator(date, message = `The date should not be before ${new DatePipe('en-US').transform(date)}`) {
+    return (control) => {
+        if (!control.value) {
+            return null;
+        }
+        // form control value can be as a Moment object - we wrap it in "new Date()" to work with it like with JS Date
+        if (new Date(control.value) >= new Date(date)) {
+            return null;
+        }
+        return { minDate: message };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWluLWRhdGUudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3ZhbGlkYXRvcnMvZGF0ZS9taW4tZGF0ZS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRTNDOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixJQUFVLEVBQ1YsVUFBa0IsaUNBQWlDLElBQUksUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRTtJQUUxRixPQUFPLENBQUMsT0FBd0IsRUFBb0IsRUFBRTtRQUNwRCxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRTtZQUNsQixPQUFPLElBQUksQ0FBQztTQUNiO1FBRUQsOEdBQThHO1FBQzlHLElBQUksSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQzdDLE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFFRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQzlCLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBYnN0cmFjdENvbnRyb2wsIFZhbGlkYXRpb25FcnJvcnMsIFZhbGlkYXRvckZuIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgRGF0ZVBpcGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG4vKipcbiAqIFZhbGlkYXRpb24gZnVuY3Rpb24sIHRoYXQgY2hlY2tzIElmIGRhdGUgZm9ybSB2YWx1ZSBpcyBtb3JlIHRoYW4gcHJvdmlkZWQgZGF0ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gbWluRGF0ZVZhbGlkYXRvcihcbiAgZGF0ZTogRGF0ZSxcbiAgbWVzc2FnZTogc3RyaW5nID0gYFRoZSBkYXRlIHNob3VsZCBub3QgYmUgYmVmb3JlICR7bmV3IERhdGVQaXBlKCdlbi1VUycpLnRyYW5zZm9ybShkYXRlKX1gXG4pOiBWYWxpZGF0b3JGbiB7XG4gIHJldHVybiAoY29udHJvbDogQWJzdHJhY3RDb250cm9sKTogVmFsaWRhdGlvbkVycm9ycyA9PiB7XG4gICAgaWYgKCFjb250cm9sLnZhbHVlKSB7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG5cbiAgICAvLyBmb3JtIGNvbnRyb2wgdmFsdWUgY2FuIGJlIGFzIGEgTW9tZW50IG9iamVjdCAtIHdlIHdyYXAgaXQgaW4gXCJuZXcgRGF0ZSgpXCIgdG8gd29yayB3aXRoIGl0IGxpa2Ugd2l0aCBKUyBEYXRlXG4gICAgaWYgKG5ldyBEYXRlKGNvbnRyb2wudmFsdWUpID49IG5ldyBEYXRlKGRhdGUpKSB7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG5cbiAgICByZXR1cm4geyBtaW5EYXRlOiBtZXNzYWdlIH07XG4gIH07XG59XG4iXX0=

package/esm2022/src/lib/validators/date-range.validator.mjs

@@ -0,0 +1,22 @@
+/**
+ * Validate date value. Date calue should be in passed dateRange
+ */
+export function dateRangeValidator(dateStart, dateEnd) {
+    // Avoid timezone hours problem when converts to UTC
+    // dateStart.setHours(0, 0, 0, 0);
+    // dateEnd.setHours(0, 0, 0, 0);
+    return (control) => {
+        // Skip empty value
+        if (!control.value) {
+            return null;
+        }
+        if (control.value < dateStart) {
+            return { dateRangeStart: dateStart };
+        }
+        if (control.value > dateEnd) {
+            return { dateRangeEnd: dateEnd };
+        }
+        return null;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1yYW5nZS52YWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvdmFsaWRhdG9ycy9kYXRlLXJhbmdlLnZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7R0FFRztBQUNILE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxTQUFlLEVBQUUsT0FBYTtJQUMvRCxvREFBb0Q7SUFDcEQsa0NBQWtDO0lBQ2xDLGdDQUFnQztJQUVoQyxPQUFPLENBQUMsT0FBMkIsRUFBb0IsRUFBRTtRQUN2RCxtQkFBbUI7UUFDbkIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUU7WUFDbEIsT0FBTyxJQUFJLENBQUM7U0FDYjtRQUVELElBQUksT0FBTyxDQUFDLEtBQUssR0FBRyxTQUFTLEVBQUU7WUFDN0IsT0FBTyxFQUFFLGNBQWMsRUFBRSxTQUFTLEVBQUUsQ0FBQztTQUN0QztRQUVELElBQUksT0FBTyxDQUFDLEtBQUssR0FBRyxPQUFPLEVBQUU7WUFDM0IsT0FBTyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsQ0FBQztTQUNsQztRQUVELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFVudHlwZWRGb3JtQ29udHJvbCwgVmFsaWRhdGlvbkVycm9ycywgVmFsaWRhdG9yRm4gfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbi8qKlxuICogVmFsaWRhdGUgZGF0ZSB2YWx1ZS4gRGF0ZSBjYWx1ZSBzaG91bGQgYmUgaW4gcGFzc2VkIGRhdGVSYW5nZVxuICovXG5leHBvcnQgZnVuY3Rpb24gZGF0ZVJhbmdlVmFsaWRhdG9yKGRhdGVTdGFydDogRGF0ZSwgZGF0ZUVuZDogRGF0ZSk6IFZhbGlkYXRvckZuIHtcbiAgLy8gQXZvaWQgdGltZXpvbmUgaG91cnMgcHJvYmxlbSB3aGVuIGNvbnZlcnRzIHRvIFVUQ1xuICAvLyBkYXRlU3RhcnQuc2V0SG91cnMoMCwgMCwgMCwgMCk7XG4gIC8vIGRhdGVFbmQuc2V0SG91cnMoMCwgMCwgMCwgMCk7XG5cbiAgcmV0dXJuIChjb250cm9sOiBVbnR5cGVkRm9ybUNvbnRyb2wpOiBWYWxpZGF0aW9uRXJyb3JzID0+IHtcbiAgICAvLyBTa2lwIGVtcHR5IHZhbHVlXG4gICAgaWYgKCFjb250cm9sLnZhbHVlKSB7XG4gICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG5cbiAgICBpZiAoY29udHJvbC52YWx1ZSA8IGRhdGVTdGFydCkge1xuICAgICAgcmV0dXJuIHsgZGF0ZVJhbmdlU3RhcnQ6IGRhdGVTdGFydCB9O1xuICAgIH1cblxuICAgIGlmIChjb250cm9sLnZhbHVlID4gZGF0ZUVuZCkge1xuICAgICAgcmV0dXJuIHsgZGF0ZVJhbmdlRW5kOiBkYXRlRW5kIH07XG4gICAgfVxuXG4gICAgcmV0dXJuIG51bGw7XG4gIH07XG59XG4iXX0=

package/esm2022/src/lib/validators/fields-sum.validator.mjs

@@ -0,0 +1,24 @@
+/**
+ * Validator that check if sum amount of provided fields is greater than provided sum
+ * @param field to check in each formArray element
+ * @param summary to compare with fields sum
+ * @param fieldAlias to show it in error message
+ */
+export function fieldsSumValidator(field, summary = 100, fieldAlias) {
+    return (formArray) => {
+        // calculate sum of desired fields in formArray control
+        const fieldsSum = formArray['controls']
+            .reduce((acc, group) => acc += group.get(field).value, 0);
+        if (fieldsSum <= summary) {
+            return null;
+        }
+        return {
+            fieldsSum: {
+                name: field,
+                alias: fieldAlias,
+                summary
+            }
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/validators/file.validator.mjs

@@ -0,0 +1,36 @@
+import { DOCUMENT_FILE_TYPES } from '../models/document/document-file-types.const';
+import { AbstractModel } from '../db/Models';
+const MAX_SIZE = 4194304;
+export class FileValidator {
+    // File max size check
+    static fileMaxSize(maxSize = MAX_SIZE) {
+        const validatorFn = (file) => {
+            // We don`t need to validate saved files, because when saving the form, the file was valid
+            if (file instanceof AbstractModel) {
+                return null;
+            }
+            return file.size > maxSize ? { fileMaxSize: { maxSize } } : null;
+        };
+        return FileValidator.fileValidation(validatorFn);
+    }
+    // File extension check
+    static fileExtensions(allowedExtensions = DOCUMENT_FILE_TYPES.all) {
+        const validatorFn = (file) => {
+            // We don`t need to validate saved files, because when saving the form, the file was valid
+            if (file instanceof AbstractModel) {
+                return null;
+            }
+            return allowedExtensions.includes(file.type) ? null : { fileExtension: { allowedExtensions: allowedExtensions.join() } };
+        };
+        return FileValidator.fileValidation(validatorFn);
+    }
+    static fileValidation(validatorFn) {
+        return (formControl) => {
+            if (!formControl.value) {
+                return null;
+            }
+            return validatorFn(formControl.value);
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/validators/greater-than.validator.mjs

@@ -0,0 +1,12 @@
+/**
+ * Validator is checking if field value is greater than passed value
+ */
+export function greaterThanValidator(value) {
+    return (control) => {
+        if (!control.value && (control.value !== 0)) {
+            return null;
+        }
+        return control.value > value ? null : { greaterThan: `The value should be greater than ${value}` };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JlYXRlci10aGFuLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi92YWxpZGF0b3JzL2dyZWF0ZXItdGhhbi52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsS0FBYTtJQUNoRCxPQUFPLENBQUMsT0FBb0IsRUFBb0IsRUFBRTtRQUNoRCxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEtBQUssQ0FBQyxDQUFDLEVBQUU7WUFDM0MsT0FBTyxJQUFJLENBQUM7U0FDYjtRQUVELE9BQU8sT0FBTyxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxXQUFXLEVBQUUsb0NBQW9DLEtBQUssRUFBRSxFQUFFLENBQUM7SUFDckcsQ0FBQyxDQUFBO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvcm1Db250cm9sLCBWYWxpZGF0aW9uRXJyb3JzLCBWYWxpZGF0b3JGbiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuLyoqXG4gKiBWYWxpZGF0b3IgaXMgY2hlY2tpbmcgaWYgZmllbGQgdmFsdWUgaXMgZ3JlYXRlciB0aGFuIHBhc3NlZCB2YWx1ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gZ3JlYXRlclRoYW5WYWxpZGF0b3IodmFsdWU6IG51bWJlcik6IFZhbGlkYXRvckZuIHtcbiAgcmV0dXJuIChjb250cm9sOiBGb3JtQ29udHJvbCk6IFZhbGlkYXRpb25FcnJvcnMgPT4ge1xuICAgIGlmICghY29udHJvbC52YWx1ZSAmJiAoY29udHJvbC52YWx1ZSAhPT0gMCkpIHtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cblxuICAgIHJldHVybiBjb250cm9sLnZhbHVlID4gdmFsdWUgPyBudWxsIDogeyBncmVhdGVyVGhhbjogYFRoZSB2YWx1ZSBzaG91bGQgYmUgZ3JlYXRlciB0aGFuICR7dmFsdWV9YCB9O1xuICB9XG59XG4iXX0=

package/esm2022/src/lib/validators/group.validator.mjs

@@ -0,0 +1,11 @@
+/**
+ * Custom validator that applies another validator to all controls in a FormGroup
+ */
+export function groupValidator(validatorFn) {
+    return (control) => {
+        const keys = Object.keys(control.controls);
+        const errors = keys.map(key => validatorFn(control.get(key))).filter(Boolean);
+        return errors.length === keys.length ? errors[0] : null;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JvdXAudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3ZhbGlkYXRvcnMvZ3JvdXAudmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FBQyxXQUF3QjtJQUNyRCxPQUFPLENBQUMsT0FBa0IsRUFBMkIsRUFBRTtRQUNyRCxNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUMzQyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU5RSxPQUFPLE1BQU0sQ0FBQyxNQUFNLEtBQUssSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFDMUQsQ0FBQyxDQUFBO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvcm1Hcm91cCwgVmFsaWRhdGlvbkVycm9ycywgVmFsaWRhdG9yRm4gfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbi8qKlxuICogQ3VzdG9tIHZhbGlkYXRvciB0aGF0IGFwcGxpZXMgYW5vdGhlciB2YWxpZGF0b3IgdG8gYWxsIGNvbnRyb2xzIGluIGEgRm9ybUdyb3VwXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBncm91cFZhbGlkYXRvcih2YWxpZGF0b3JGbjogVmFsaWRhdG9yRm4pOiBWYWxpZGF0b3JGbiB7XG4gIHJldHVybiAoY29udHJvbDogRm9ybUdyb3VwKTogVmFsaWRhdGlvbkVycm9ycyB8IG51bGwgPT4ge1xuICAgIGNvbnN0IGtleXMgPSBPYmplY3Qua2V5cyhjb250cm9sLmNvbnRyb2xzKTtcbiAgICBjb25zdCBlcnJvcnMgPSBrZXlzLm1hcChrZXkgPT4gdmFsaWRhdG9yRm4oY29udHJvbC5nZXQoa2V5KSkpLmZpbHRlcihCb29sZWFuKTtcblxuICAgIHJldHVybiBlcnJvcnMubGVuZ3RoID09PSBrZXlzLmxlbmd0aCA/IGVycm9yc1swXSA6IG51bGw7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/lib/validators/index.mjs

@@ -0,0 +1,15 @@
+export * from './at-least-one.validator';
+export * from './autocomplete.validator';
+export * from './conditional.validator';
+export * from './password.validator';
+export * from './password-match.validator';
+export * from './date/min-date.validator';
+export * from './date/max-date.validator';
+export * from './fields-sum.validator';
+export * from './current-fin-year.validator';
+export * from './file.validator';
+export * from './greater-than.validator';
+export * from './unique-email.validator';
+export * from './string/alpha-space.validator';
+export * from './match-sum.validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvdmFsaWRhdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F0LWxlYXN0LW9uZS52YWxpZGF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRvY29tcGxldGUudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vY29uZGl0aW9uYWwudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vcGFzc3dvcmQudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vcGFzc3dvcmQtbWF0Y2gudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0ZS9taW4tZGF0ZS52YWxpZGF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlL21heC1kYXRlLnZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2ZpZWxkcy1zdW0udmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vY3VycmVudC1maW4teWVhci52YWxpZGF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9maWxlLnZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2dyZWF0ZXItdGhhbi52YWxpZGF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi91bmlxdWUtZW1haWwudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vc3RyaW5nL2FscGhhLXNwYWNlLnZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL21hdGNoLXN1bS52YWxpZGF0b3InO1xuIl19