@messaia/cdk 12.3.5-rc21 → 13.0.0-rc02

package/esm2020/lib/table/paginator-intl.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { MatPaginatorIntl } from '@angular/material/paginator';
+import * as i0 from "@angular/core";
+/**
+ * To modify the labels and text displayed, create a new instance of MdPaginatorIntl and
+ * include it in a custom provider
+ */
+export class PaginatorIntl extends MatPaginatorIntl {
+    constructor() {
+        super(...arguments);
+        /**
+         * A label for the page size selector
+         */
+        this.itemsPerPageLabel = '';
+        /**
+         * A label for the button that increments the current page
+         */
+        this.nextPageLabel = '';
+        /**
+         * A label for the button that decrements the current page
+         */
+        this.previousPageLabel = '';
+        /**
+         * A label for the range of items within the current page
+         * and the length of the whole list
+         */
+        this.getRangeLabel = (page, pageSize, length) => {
+            if (length == 0 || pageSize == 0) {
+                return `0 / ${length}`;
+            }
+            length = Math.max(length, 0);
+            const startIndex = page * pageSize;
+            /* If the start index exceeds the list length, do not try and fix the end index to the end */
+            const endIndex = startIndex < length ? Math.min(startIndex + pageSize, length) : startIndex + pageSize;
+            return `${startIndex + 1} - ${endIndex} / ${length}`;
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ PaginatorIntl.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: PaginatorIntl, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ PaginatorIntl.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: PaginatorIntl });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: PaginatorIntl, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/table/public_api.mjs

@@ -0,0 +1,3 @@
+export * from './components/filter-select.component';
+export * from './table.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL3RhYmxlL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL2ZpbHRlci1zZWxlY3QuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90YWJsZS5tb2R1bGUnO1xyXG4iXX0=

package/esm2020/lib/table/table.data-source.mjs

@@ -0,0 +1,210 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { DataSource } from '@angular/cdk/table';
+import { BehaviorSubject, merge, of as observableOf } from 'rxjs';
+import { catchError, map, skip, switchMap } from 'rxjs/operators';
+import { Utils } from '../common/functions/utils';
+/**
+ * A generic datasource for data-table
+ */
+export class TableDataSource extends DataSource {
+    /**
+     * Constructor
+     * @param service
+     * @param paginator
+     * @param sort
+     */
+    constructor(service, paginator, sort) {
+        super();
+        this.service = service;
+        this.paginator = paginator;
+        this.sort = sort;
+        /**
+         * Represents a value that changes over time.
+         * Observers can subscribe to the subject to receive filter changes
+         */
+        this._filterChange = new BehaviorSubject('');
+        /**
+         * onDataLoaded: function($event)
+         * Event emitted after the data is loaded
+         */
+        this._reloadChange = new BehaviorSubject(0);
+        /**
+         * onDataLoaded: function($event)
+         * Event emitted after the data is loaded
+         */
+        this.onDataLoaded = new BehaviorSubject(null);
+        /**
+         * Used to power selecting one or more options from a list.
+         */
+        this.selectionModel = new SelectionModel(true, []);
+        /**
+         * The navigations to includes
+         */
+        this.includes = [];
+        /**
+         * The list of items
+         */
+        this.items = [];
+        /**
+         * Used to add some field filters
+         */
+        this.fieldFilters = {};
+        /**
+         * Used to add some field operators
+         */
+        this.fieldOperators = {};
+        /**
+         * Used to add some static field filters
+         */
+        this.staticFieldFilters = {};
+        /**
+         * The current page index.
+         */
+        this.pageIndex = 0;
+        /**
+         * The current total number of items being paged
+         */
+        this.total = 0;
+        /**
+         * The current page size
+         */
+        this.pageSize = 15;
+        /**
+         * Number of pages
+         */
+        this.pageCount = 0;
+        /**
+         * A flag to show loading process
+         */
+        this.isLoading = true;
+    }
+    /**
+     * Gets filter
+     */
+    get filter() { return this._filterChange.value; }
+    /**
+     * Sets filter
+     */
+    set filter(filter) {
+        if (this.paginator) {
+            this.paginator.pageIndex = 0;
+            this.pageIndex = 0;
+        }
+        this._filterChange.next(filter);
+    }
+    /**
+     * Gets reload token
+     */
+    get reloadToken() { return this._reloadChange.value; }
+    /**
+     * Connects a collection viewer (such as a data-table) to this data source.
+     * @param collectionViewer The component that exposes a view over the data provided by this
+     *     data source.
+     * @returns Observable that emits a new value when the data changes.
+     */
+    connect() {
+        /* A list of fields to observe  */
+        const displayDataChanges = [
+            this.sort?.sortChange,
+            this.paginator?.page || 1,
+            this._filterChange,
+            this._reloadChange
+        ];
+        /* If the user changes the sort order, reset back to the first page */
+        this.sort.sortChange.subscribe(() => { this.paginator.pageIndex = 0; });
+        return merge(...displayDataChanges)
+            .pipe(skip(1), switchMap(() => {
+            /* Flip flag to show that loading has begun */
+            this.isLoading = true;
+            /* Remove empty filters */
+            Object.keys(this.fieldFilters).forEach((key) => ((this.fieldFilters[key] == null || this.fieldFilters[key] == '' || this.fieldFilters[key] == 'undefined')) && this.fieldFilters[key] != 0 && delete this.fieldFilters[key]);
+            Object.keys(this.staticFieldFilters).forEach((key) => ((this.staticFieldFilters[key] == null || this.staticFieldFilters[key] == '' || this.staticFieldFilters[key] == 'undefined')) && this.staticFieldFilters[key] != 0 && delete this.staticFieldFilters[key]);
+            /* Load data and return it */
+            return this.service.getList(Object.assign({
+                includes: this.includes,
+                projection: this.projection,
+                page: this.paginator.pageIndex + 1,
+                pageSize: this.paginator.pageSize,
+                search: this.filter.toLowerCase(),
+                sortBy: this.sort.active,
+                sortOrder: this.sort.direction
+            }, Utils.cleanObject(this.fieldFilters) || {}, this.staticFieldFilters), null, { 'CheckOut': 'Yes' });
+        }), map((result) => {
+            /* Flip flag to show that loading has finished */
+            this.isLoading = false;
+            /* Update pagination fields */
+            this.pageIndex = Math.max(Math.min(result.page - 1, result.pageCount - 1), 0);
+            this.total = result.total;
+            this.pageSize = result.pageSize;
+            this.pageCount = result.pageCount;
+            this.items = result.items;
+            /* Raise onload event */
+            this.onDataLoaded.next(result);
+            return this.items;
+        }), catchError(() => {
+            /* Flip flag to show that loading has finished */
+            this.isLoading = false;
+            return observableOf([]);
+        }));
+    }
+    /**
+     * Disconnects a collection viewer (such as a data-table) from this data source. Can be used
+     * to perform any clean-up or tear-down operations when a view is being destroyed.
+     *
+     * @param collectionViewer The component that exposes a view over the data provided by this
+     *     data source.
+     */
+    disconnect() { }
+    /**
+     * Reloads items
+     * @param clearSelection
+     */
+    reload(clearSelection = true) {
+        this._reloadChange.next(Math.random());
+        if (clearSelection) {
+            this.selectionModel.clear();
+        }
+    }
+    /**
+     * Clears field filters
+     */
+    clearFilters(newFilters = {}) {
+        this.fieldFilters = newFilters || {};
+        this.reload();
+    }
+    /**
+     * Checks, whether all items are selected
+     */
+    isAllSelected() {
+        if (this.selectionModel.isEmpty()) {
+            return false;
+        }
+        return this.selectionModel.selected.length === this.total;
+    }
+    /**
+     * Toggles selected items
+     * @param checkbox
+     * @param predicate
+     */
+    toggleSelect(checkbox, predicate) {
+        if (this.selectionModel.hasValue()) {
+            this.selectionModel.clear();
+            checkbox.source.checked = false;
+        }
+        else {
+            this.items.filter(predicate ? predicate : x => x)
+                .filter(x => !x['locked'])
+                .forEach(data => this.selectionModel.select(data['id']));
+            if (this.selectionModel.selected.length !== this.total) {
+                checkbox.source.checked = false;
+            }
+        }
+    }
+    /**
+     * Get selected Items
+     */
+    getSelected() {
+        return this.selectionModel.selected;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.data-source.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/table/table.data-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { SelectionModel } from '@angular/cdk/collections';\r\nimport { DataSource } from '@angular/cdk/table';\r\nimport { MatCheckboxChange } from '@angular/material/checkbox';\r\nimport { MatPaginator } from '@angular/material/paginator';\r\nimport { MatSort } from '@angular/material/sort';\r\nimport { BehaviorSubject, merge, Observable, of as observableOf } from 'rxjs';\r\nimport { catchError, map, skip, switchMap } from 'rxjs/operators';\r\nimport { Utils } from '../common/functions/utils';\r\nimport { GenericService } from '../http/services/generic.service';\r\nimport { Pagination } from './models/pagination';\r\n\r\n/**\r\n * A generic datasource for data-table\r\n */\r\nexport class TableDataSource<TEntity, TService extends GenericService<TEntity>> extends DataSource<TEntity> {\r\n\r\n\t/**\r\n\t * Represents a value that changes over time. \r\n\t * Observers can subscribe to the subject to receive filter changes\r\n\t */\r\n\tprivate _filterChange = new BehaviorSubject('');\r\n\r\n\t/**\r\n\t * onDataLoaded: function($event)\r\n\t * Event emitted after the data is loaded\r\n\t */\r\n\tpublic _reloadChange = new BehaviorSubject<number>(0);\r\n\r\n\t/**\r\n\t * onDataLoaded: function($event)\r\n\t * Event emitted after the data is loaded\r\n\t */\r\n\tpublic onDataLoaded = new BehaviorSubject<Pagination<TEntity>>(null);\r\n\r\n\t/**\r\n\t * Used to power selecting one or more options from a list.\r\n\t */\r\n\tpublic selectionModel = new SelectionModel<number>(true, []);\r\n\r\n\t/**\r\n\t * Gets filter\r\n\t */\r\n\tget filter(): string { return this._filterChange.value; }\r\n\r\n\t/**\r\n\t * Sets filter\r\n\t */\r\n\tset filter(filter: string) {\r\n\t\tif (this.paginator) {\r\n\t\t\tthis.paginator.pageIndex = 0;\r\n\t\t\tthis.pageIndex = 0;\r\n\t\t}\r\n\r\n\t\tthis._filterChange.next(filter);\r\n\t}\r\n\r\n\t/**\r\n\t * Gets reload token\r\n\t */\r\n\tget reloadToken(): number { return this._reloadChange.value; }\r\n\r\n\t/**\r\n\t * The navigations to includes\r\n\t */\r\n\tpublic includes: Array<string> = [];\r\n\r\n\t/**\r\n\t * The columns to be projected\r\n\t */\r\n\tpublic projection: string;\r\n\r\n\t/**\r\n\t * The list of items\r\n\t */\r\n\tpublic items: TEntity[] = [];\r\n\r\n\t/**\r\n\t * Used to add some field filters\r\n\t */\r\n\tpublic fieldFilters: any = {};\r\n\r\n\t/**\r\n\t * Used to add some field operators\r\n\t */\r\n\tpublic fieldOperators: any = {};\r\n\r\n\t/**\r\n\t * Used to add some static field filters\r\n\t */\r\n\tpublic staticFieldFilters: any = {};\r\n\r\n\t/**\r\n\t * The current page index.\r\n\t */\r\n\tpublic pageIndex: number = 0;\r\n\r\n\t/**\r\n\t * The current total number of items being paged\r\n\t */\r\n\tpublic total: number = 0;\r\n\r\n\t/**\r\n\t * The current page size\r\n\t */\r\n\tpublic pageSize: number = 15;\r\n\r\n\t/**\r\n\t * Number of pages\r\n\t */\r\n\tpublic pageCount: number = 0;\r\n\r\n\t/**\r\n\t * A flag to show loading process\r\n\t */\r\n\tpublic isLoading: boolean = true;\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param service \r\n\t * @param paginator \r\n\t * @param sort \r\n\t */\r\n\tconstructor(\r\n\t\tpublic service: TService,\r\n\t\tpublic paginator: MatPaginator,\r\n\t\tpublic sort: MatSort\r\n\t) {\r\n\t\tsuper();\r\n\t}\r\n\r\n\t/**\r\n\t * Connects a collection viewer (such as a data-table) to this data source.\r\n\t * @param collectionViewer The component that exposes a view over the data provided by this\r\n\t *     data source.\r\n\t * @returns Observable that emits a new value when the data changes.\r\n\t */\r\n\tconnect(): Observable<TEntity[]> {\r\n\t\t/* A list of fields to observe  */\r\n\t\tconst displayDataChanges = [\r\n\t\t\tthis.sort?.sortChange,\r\n\t\t\tthis.paginator?.page || 1,\r\n\t\t\tthis._filterChange,\r\n\t\t\tthis._reloadChange\r\n\t\t];\r\n\r\n\t\t/* If the user changes the sort order, reset back to the first page */\r\n\t\tthis.sort.sortChange.subscribe(() => { this.paginator.pageIndex = 0; });\r\n\r\n\t\treturn merge(...displayDataChanges)\r\n\t\t\t.pipe(\r\n\t\t\t\tskip(1),\r\n\t\t\t\tswitchMap(() => {\r\n\t\t\t\t\t/* Flip flag to show that loading has begun */\r\n\t\t\t\t\tthis.isLoading = true;\r\n\r\n\t\t\t\t\t/* Remove empty filters */\r\n\t\t\t\t\tObject.keys(this.fieldFilters).forEach((key) => ((this.fieldFilters[key] == null || this.fieldFilters[key] == '' || this.fieldFilters[key] == 'undefined')) && this.fieldFilters[key] != 0 && delete this.fieldFilters[key]);\r\n\t\t\t\t\tObject.keys(this.staticFieldFilters).forEach((key) => ((this.staticFieldFilters[key] == null || this.staticFieldFilters[key] == '' || this.staticFieldFilters[key] == 'undefined')) && this.staticFieldFilters[key] != 0 && delete this.staticFieldFilters[key]);\r\n\r\n\t\t\t\t\t/* Load data and return it */\r\n\t\t\t\t\treturn this.service.getList(Object.assign({\r\n\t\t\t\t\t\tincludes: this.includes,\r\n\t\t\t\t\t\tprojection: this.projection,\r\n\t\t\t\t\t\tpage: this.paginator.pageIndex + 1,\r\n\t\t\t\t\t\tpageSize: this.paginator.pageSize,\r\n\t\t\t\t\t\tsearch: this.filter.toLowerCase(),\r\n\t\t\t\t\t\tsortBy: this.sort.active,\r\n\t\t\t\t\t\tsortOrder: this.sort.direction\r\n\t\t\t\t\t}, Utils.cleanObject(this.fieldFilters) || {}, this.staticFieldFilters), null, { 'CheckOut': 'Yes' });\r\n\t\t\t\t}),\r\n\t\t\t\tmap((result: any) => {\r\n\t\t\t\t\t/* Flip flag to show that loading has finished */\r\n\t\t\t\t\tthis.isLoading = false;\r\n\r\n\t\t\t\t\t/* Update pagination fields */\r\n\t\t\t\t\tthis.pageIndex = Math.max(Math.min(result.page - 1, result.pageCount - 1), 0);\r\n\t\t\t\t\tthis.total = result.total;\r\n\t\t\t\t\tthis.pageSize = result.pageSize;\r\n\t\t\t\t\tthis.pageCount = result.pageCount;\r\n\t\t\t\t\tthis.items = result.items;\r\n\r\n\t\t\t\t\t/* Raise onload event */\r\n\t\t\t\t\tthis.onDataLoaded.next(result);\r\n\r\n\t\t\t\t\treturn this.items;\r\n\t\t\t\t}),\r\n\t\t\t\tcatchError(() => {\r\n\t\t\t\t\t/* Flip flag to show that loading has finished */\r\n\t\t\t\t\tthis.isLoading = false;\r\n\r\n\t\t\t\t\treturn observableOf([]);\r\n\t\t\t\t}));\r\n\t}\r\n\r\n\t/**\r\n\t * Disconnects a collection viewer (such as a data-table) from this data source. Can be used\r\n\t * to perform any clean-up or tear-down operations when a view is being destroyed.\r\n\t *\r\n\t * @param collectionViewer The component that exposes a view over the data provided by this\r\n\t *     data source.\r\n\t */\r\n\tdisconnect(): void { }\r\n\r\n\t/**\r\n\t * Reloads items\r\n\t * @param clearSelection \r\n\t */\r\n\tpublic reload(clearSelection: boolean = true): void {\r\n\t\tthis._reloadChange.next(Math.random());\r\n\r\n\t\tif (clearSelection) {\r\n\t\t\tthis.selectionModel.clear();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Clears field filters\r\n\t */\r\n\tpublic clearFilters(newFilters: any = {}): void {\r\n\t\tthis.fieldFilters = newFilters || {};\r\n\t\tthis.reload();\r\n\t}\r\n\r\n\t/**\r\n\t * Checks, whether all items are selected\r\n\t */\r\n\tpublic isAllSelected(): boolean {\r\n\t\tif (this.selectionModel.isEmpty()) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\treturn this.selectionModel.selected.length === this.total;\r\n\t}\r\n\r\n\t/**\r\n\t * Toggles selected items\r\n\t * @param checkbox \r\n\t * @param predicate\r\n\t */\r\n\tpublic toggleSelect(checkbox: MatCheckboxChange, predicate?: (value: TEntity, index: number, array: TEntity[]) => unknown) {\r\n\t\tif (this.selectionModel.hasValue()) {\r\n\t\t\tthis.selectionModel.clear();\r\n\t\t\tcheckbox.source.checked = false;\r\n\t\t} else {\r\n\t\t\tthis.items.filter(predicate ? predicate : x => x)\r\n\t\t\t\t.filter(x => !x['locked'])\r\n\t\t\t\t.forEach(data => this.selectionModel.select(data['id']));\r\n\r\n\t\t\tif (this.selectionModel.selected.length !== this.total) {\r\n\t\t\t\tcheckbox.source.checked = false;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Get selected Items\r\n\t */\r\n\tpublic getSelected(): number[] {\r\n\t\treturn this.selectionModel.selected;\r\n\t}\r\n}"]}

package/esm2020/lib/table/table.module.mjs

@@ -0,0 +1,140 @@
+import { CdkTableModule } from '@angular/cdk/table';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatPaginatorIntl, MatPaginatorModule } from '@angular/material/paginator';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSortModule } from '@angular/material/sort';
+import { MatTableModule } from '@angular/material/table';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { VdCommonModule } from '../common/common.module';
+import { VdDynamicTableComponent } from './components/dynamic-table/dynamic-table.component';
+import { FilterClearComponent } from './components/filter-clear.component';
+import { FilterDateComponent } from './components/filter-date.component';
+import { FilterInputComponent } from './components/filter-input.component';
+import { FilterSelectComponent, VdFilterOptionDirective } from './components/filter-select.component';
+import { DataSourceFilterDirective } from './directives/data-source-filter.directive';
+import { PaginatorIntl } from './paginator-intl';
+import * as i0 from "@angular/core";
+export { VdDynamicTableComponent } from './components/dynamic-table/dynamic-table.component';
+export { FilterClearComponent } from './components/filter-clear.component';
+export { FilterDateComponent } from './components/filter-date.component';
+export { FilterInputComponent } from './components/filter-input.component';
+export { FilterSelectComponent } from './components/filter-select.component';
+export { DataSourceFilterDirective } from './directives/data-source-filter.directive';
+export { TableColumnType } from './enums/table-column-type';
+export { Column, Table } from './functions/decorators';
+export { getTableDefinition } from './functions/functions';
+export { Pagination } from './models/pagination';
+export { TableColumn } from './models/table-column';
+export { TableDefinition } from './models/table-definition';
+export { TableMenuItem } from './models/table-menu-item';
+export { TableDataSource } from './table.data-source';
+export { TableStaticDataSource } from './table.static-data-source';
+const DECLARATIONS = [
+    FilterInputComponent,
+    FilterSelectComponent,
+    FilterClearComponent,
+    FilterDateComponent,
+    DataSourceFilterDirective,
+    VdFilterOptionDirective,
+    VdDynamicTableComponent
+];
+export class VdTableModule {
+}
+/** @nocollapse */ /** @nocollapse */ VdTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ VdTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdTableModule, declarations: [FilterInputComponent,
+        FilterSelectComponent,
+        FilterClearComponent,
+        FilterDateComponent,
+        DataSourceFilterDirective,
+        VdFilterOptionDirective,
+        VdDynamicTableComponent], imports: [CommonModule,
+        VdCommonModule,
+        FormsModule,
+        MatButtonModule,
+        MatFormFieldModule,
+        MatSelectModule,
+        MatIconModule,
+        MatInputModule,
+        MatDatepickerModule,
+        MatTableModule,
+        MatSortModule,
+        CdkTableModule,
+        MatProgressBarModule,
+        MatCheckboxModule,
+        MatButtonModule,
+        MatMenuModule,
+        MatSlideToggleModule,
+        MatPaginatorModule,
+        MatTooltipModule], exports: [FilterInputComponent,
+        FilterSelectComponent,
+        FilterClearComponent,
+        FilterDateComponent,
+        DataSourceFilterDirective,
+        VdFilterOptionDirective,
+        VdDynamicTableComponent] });
+/** @nocollapse */ /** @nocollapse */ VdTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdTableModule, providers: [
+        { provide: MatPaginatorIntl, useClass: PaginatorIntl }
+    ], imports: [[
+            CommonModule,
+            VdCommonModule,
+            FormsModule,
+            MatButtonModule,
+            MatFormFieldModule,
+            MatSelectModule,
+            MatIconModule,
+            MatInputModule,
+            MatDatepickerModule,
+            MatTableModule,
+            MatSortModule,
+            CdkTableModule,
+            MatProgressBarModule,
+            MatCheckboxModule,
+            MatButtonModule,
+            MatMenuModule,
+            MatSlideToggleModule,
+            MatPaginatorModule,
+            MatTooltipModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        VdCommonModule,
+                        FormsModule,
+                        MatButtonModule,
+                        MatFormFieldModule,
+                        MatSelectModule,
+                        MatIconModule,
+                        MatInputModule,
+                        MatDatepickerModule,
+                        MatTableModule,
+                        MatSortModule,
+                        CdkTableModule,
+                        MatProgressBarModule,
+                        MatCheckboxModule,
+                        MatButtonModule,
+                        MatMenuModule,
+                        MatSlideToggleModule,
+                        MatPaginatorModule,
+                        MatTooltipModule
+                    ],
+                    exports: [DECLARATIONS],
+                    declarations: [DECLARATIONS],
+                    providers: [
+                        { provide: MatPaginatorIntl, useClass: PaginatorIntl }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.module.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/table/table.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oDAAoD,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AACtG,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;;AAEjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oDAAoD,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,MAAM,YAAY,GAAG;IACpB,oBAAoB;IACpB,qBAAqB;IACrB,oBAAoB;IACpB,mBAAmB;IACnB,yBAAyB;IACzB,uBAAuB;IACvB,uBAAuB;CACvB,CAAC;AA8BF,MAAM,OAAO,aAAa;;gJAAb,aAAa;iJAAb,aAAa,iBArCzB,oBAAoB;QACpB,qBAAqB;QACrB,oBAAoB;QACpB,mBAAmB;QACnB,yBAAyB;QACzB,uBAAuB;QACvB,uBAAuB,aAKtB,YAAY;QACZ,cAAc;QACd,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,eAAe;QACf,aAAa;QACb,cAAc;QACd,mBAAmB;QACnB,cAAc;QACd,aAAa;QACb,cAAc;QACd,oBAAoB;QACpB,iBAAiB;QACjB,eAAe;QACf,aAAa;QACb,oBAAoB;QACpB,kBAAkB;QAClB,gBAAgB,aA7BjB,oBAAoB;QACpB,qBAAqB;QACrB,oBAAoB;QACpB,mBAAmB;QACnB,yBAAyB;QACzB,uBAAuB;QACvB,uBAAuB;iJA+BX,aAAa,aAJd;QACV,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,aAAa,EAAE;KACtD,YAzBQ;YACR,YAAY;YACZ,cAAc;YACd,WAAW;YACX,eAAe;YACf,kBAAkB;YAClB,eAAe;YACf,aAAa;YACb,cAAc;YACd,mBAAmB;YACnB,cAAc;YACd,aAAa;YACb,cAAc;YACd,oBAAoB;YACpB,iBAAiB;YACjB,eAAe;YACf,aAAa;YACb,oBAAoB;YACpB,kBAAkB;YAClB,gBAAgB;SAChB;2FAOW,aAAa;kBA5BzB,QAAQ;mBAAC;oBACT,OAAO,EAAE;wBACR,YAAY;wBACZ,cAAc;wBACd,WAAW;wBACX,eAAe;wBACf,kBAAkB;wBAClB,eAAe;wBACf,aAAa;wBACb,cAAc;wBACd,mBAAmB;wBACnB,cAAc;wBACd,aAAa;wBACb,cAAc;wBACd,oBAAoB;wBACpB,iBAAiB;wBACjB,eAAe;wBACf,aAAa;wBACb,oBAAoB;wBACpB,kBAAkB;wBAClB,gBAAgB;qBAChB;oBACD,OAAO,EAAE,CAAC,YAAY,CAAC;oBACvB,YAAY,EAAE,CAAC,YAAY,CAAC;oBAC5B,SAAS,EAAE;wBACV,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,aAAa,EAAE;qBACtD;iBACD","sourcesContent":["import { CdkTableModule } from '@angular/cdk/table';\r\nimport { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatFormFieldModule } from '@angular/material/form-field';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatMenuModule } from '@angular/material/menu';\r\nimport { MatPaginatorIntl, MatPaginatorModule } from '@angular/material/paginator';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\r\nimport { MatSortModule } from '@angular/material/sort';\r\nimport { MatTableModule } from '@angular/material/table';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { VdCommonModule } from '../common/common.module';\r\nimport { VdDynamicTableComponent } from './components/dynamic-table/dynamic-table.component';\r\nimport { FilterClearComponent } from './components/filter-clear.component';\r\nimport { FilterDateComponent } from './components/filter-date.component';\r\nimport { FilterInputComponent } from './components/filter-input.component';\r\nimport { FilterSelectComponent, VdFilterOptionDirective } from './components/filter-select.component';\r\nimport { DataSourceFilterDirective } from './directives/data-source-filter.directive';\r\nimport { PaginatorIntl } from './paginator-intl';\r\n\r\nexport { VdDynamicTableComponent } from './components/dynamic-table/dynamic-table.component';\r\nexport { FilterClearComponent } from './components/filter-clear.component';\r\nexport { FilterDateComponent } from './components/filter-date.component';\r\nexport { FilterInputComponent } from './components/filter-input.component';\r\nexport { FilterSelectComponent } from './components/filter-select.component';\r\nexport { DataSourceFilterDirective } from './directives/data-source-filter.directive';\r\nexport { TableColumnType } from './enums/table-column-type';\r\nexport { Column, Table } from './functions/decorators';\r\nexport { getTableDefinition } from './functions/functions';\r\nexport { Pagination } from './models/pagination';\r\nexport { TableColumn } from './models/table-column';\r\nexport { TableDefinition } from './models/table-definition';\r\nexport { TableMenuItem } from './models/table-menu-item';\r\nexport { TableDataSource } from './table.data-source';\r\nexport { TableStaticDataSource } from './table.static-data-source';\r\n\r\nconst DECLARATIONS = [\r\n\tFilterInputComponent,\r\n\tFilterSelectComponent,\r\n\tFilterClearComponent,\r\n\tFilterDateComponent,\r\n\tDataSourceFilterDirective,\r\n\tVdFilterOptionDirective,\r\n\tVdDynamicTableComponent\r\n];\r\n\r\n@NgModule({\r\n\timports: [\r\n\t\tCommonModule,\r\n\t\tVdCommonModule,\r\n\t\tFormsModule,\r\n\t\tMatButtonModule,\r\n\t\tMatFormFieldModule,\r\n\t\tMatSelectModule,\r\n\t\tMatIconModule,\r\n\t\tMatInputModule,\r\n\t\tMatDatepickerModule,\r\n\t\tMatTableModule,\r\n\t\tMatSortModule,\r\n\t\tCdkTableModule,\r\n\t\tMatProgressBarModule,\r\n\t\tMatCheckboxModule,\r\n\t\tMatButtonModule,\r\n\t\tMatMenuModule,\r\n\t\tMatSlideToggleModule,\r\n\t\tMatPaginatorModule,\r\n\t\tMatTooltipModule\r\n\t],\r\n\texports: [DECLARATIONS],\r\n\tdeclarations: [DECLARATIONS],\r\n\tproviders: [\r\n\t\t{ provide: MatPaginatorIntl, useClass: PaginatorIntl }\r\n\t]\r\n})\r\nexport class VdTableModule { }"]}

package/esm2020/lib/table/table.static-data-source.mjs

@@ -0,0 +1,133 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { MatTableDataSource } from '@angular/material/table';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * A generic datasource for data-table
+ */
+export class TableStaticDataSource extends MatTableDataSource {
+    constructor() {
+        super(...arguments);
+        /**
+         * onDataLoaded: function($event)
+         * Event emitted after the data is loaded
+         */
+        this._reloadChange = new BehaviorSubject(0);
+        /**
+         * onDataLoaded: function($event)
+         * Event emitted after the data is loaded
+         */
+        this.onDataLoaded = new BehaviorSubject(null);
+        /**
+         * Used to power selecting one or more options from a list.
+         */
+        this.selectionModel = new SelectionModel(true, []);
+        /**
+         * Used to add some field filters
+         */
+        this.fieldFilters = {};
+        /**
+         * Used to add some field operators
+         */
+        this.fieldOperators = {};
+        /**
+         * Used to add some static field filters
+         */
+        this.staticFieldFilters = {};
+        /**
+         * The current page index.
+         */
+        this.pageIndex = 0;
+        /**
+         * The current total number of items being paged
+         */
+        this.total = 0;
+        /**
+         * The current page size
+         */
+        this.pageSize = 15;
+        /**
+         * Number of pages
+         */
+        this.pageCount = 0;
+        /**
+         * A flag to show loading process
+         */
+        this.isLoading = false;
+    }
+    /**
+     * Gets reload token
+     */
+    get reloadToken() { return this._reloadChange.value; }
+    /**
+     * Reloads items
+     * @param clearSelection
+     */
+    reload(clearSelection = true) {
+        this._reloadChange.next(Math.random());
+        if (clearSelection) {
+            this.selectionModel.clear();
+        }
+    }
+    /**
+     * Used by the MatTable. Called when it connects to the data source.
+     * @docs-private
+     */
+    connect() {
+        this._reloadChange.subscribe(x => {
+            /* Remove empty filters */
+            Object.keys(this.fieldFilters).forEach((key) => ((this.fieldFilters[key] == null || this.fieldFilters[key] == '' || this.fieldFilters[key] == 'undefined')) && this.fieldFilters[key] != 0 && delete this.fieldFilters[key]);
+            Object.keys(this.staticFieldFilters).forEach((key) => ((this.staticFieldFilters[key] == null || this.staticFieldFilters[key] == '' || this.staticFieldFilters[key] == 'undefined')) && this.staticFieldFilters[key] != 0 && delete this.staticFieldFilters[key]);
+            Object.keys(this.fieldFilters).forEach((key) => {
+                this.filterPredicate = (data, filter) => !filter || `${data[key]}`.toLowerCase().includes(`${this.filter}`?.toLowerCase());
+                this.filter = this.fieldFilters[key];
+            });
+        });
+        return super.connect();
+    }
+    /**
+     * Clears field filters
+     */
+    clearFilters(newFilters = {}) {
+        if (this.paginator) {
+            this.paginator.pageIndex = 0;
+        }
+        this.fieldFilters = newFilters || {};
+        this.filter = '';
+        this.reload();
+    }
+    /**
+     * Checks, whether all items are selected
+     */
+    isAllSelected() {
+        if (this.selectionModel.isEmpty()) {
+            return false;
+        }
+        return this.selectionModel.selected.length === this.paginator?.length;
+    }
+    /**
+     * Toggles selected items
+     * @param checkbox
+     * @param predicate
+     */
+    toggleSelect(checkbox, predicate) {
+        if (this.selectionModel.hasValue()) {
+            this.selectionModel.clear();
+            checkbox.source.checked = false;
+        }
+        else {
+            this.data.filter(predicate ? predicate : x => x)
+                .filter(x => !x['locked'])
+                .forEach(data => this.selectionModel.select(data['id']));
+            if (this.selectionModel.selected.length !== this.paginator?.length) {
+                checkbox.source.checked = false;
+            }
+        }
+    }
+    /**
+     * Get selected Items
+     */
+    getSelected() {
+        return this.selectionModel.selected;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.static-data-source.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/table/table.static-data-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { SelectionModel } from '@angular/cdk/collections';\r\nimport { MatCheckboxChange } from '@angular/material/checkbox';\r\nimport { MatTableDataSource } from '@angular/material/table';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { Pagination } from './models/pagination';\r\n\r\n/**\r\n * A generic datasource for data-table\r\n */\r\nexport class TableStaticDataSource<TEntity> extends MatTableDataSource<TEntity> {\r\n\r\n\t/**\r\n\t * onDataLoaded: function($event)\r\n\t * Event emitted after the data is loaded\r\n\t */\r\n\tpublic _reloadChange = new BehaviorSubject<number>(0);\r\n\r\n\t/**\r\n\t * onDataLoaded: function($event)\r\n\t * Event emitted after the data is loaded\r\n\t */\r\n\tpublic onDataLoaded = new BehaviorSubject<Pagination<TEntity>>(null);\r\n\r\n\t/**\r\n\t * Used to power selecting one or more options from a list.\r\n\t */\r\n\tpublic selectionModel = new SelectionModel<number>(true, []);\r\n\r\n\t/**\r\n\t * Gets reload token\r\n\t */\r\n\tget reloadToken(): number { return this._reloadChange.value; }\r\n\r\n\t/**\r\n\t * Used to add some field filters\r\n\t */\r\n\tpublic fieldFilters: any = {};\r\n\r\n\t/**\r\n\t * Used to add some field operators\r\n\t */\r\n\tpublic fieldOperators: any = {};\r\n\r\n\t/**\r\n\t * Used to add some static field filters\r\n\t */\r\n\tpublic staticFieldFilters: any = {};\r\n\r\n\t/**\r\n\t * The current page index.\r\n\t */\r\n\tpublic pageIndex: number = 0;\r\n\r\n\t/**\r\n\t * The current total number of items being paged\r\n\t */\r\n\tpublic total: number = 0;\r\n\r\n\t/**\r\n\t * The current page size\r\n\t */\r\n\tpublic pageSize: number = 15;\r\n\r\n\t/**\r\n\t * Number of pages\r\n\t */\r\n\tpublic pageCount: number = 0;\r\n\r\n\t/**\r\n\t * A flag to show loading process\r\n\t */\r\n\tpublic isLoading: boolean = false;\r\n\r\n\t/**\r\n\t * Reloads items\r\n\t * @param clearSelection \r\n\t */\r\n\tpublic reload(clearSelection: boolean = true): void {\r\n\t\tthis._reloadChange.next(Math.random());\r\n\r\n\t\tif (clearSelection) {\r\n\t\t\tthis.selectionModel.clear();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Used by the MatTable. Called when it connects to the data source.\r\n\t * @docs-private\r\n\t */\r\n\tconnect(): BehaviorSubject<TEntity[]> {\r\n\t\tthis._reloadChange.subscribe(x => {\r\n\t\t\t/* Remove empty filters */\r\n\t\t\tObject.keys(this.fieldFilters).forEach((key) => ((this.fieldFilters[key] == null || this.fieldFilters[key] == '' || this.fieldFilters[key] == 'undefined')) && this.fieldFilters[key] != 0 && delete this.fieldFilters[key]);\r\n\t\t\tObject.keys(this.staticFieldFilters).forEach((key) => ((this.staticFieldFilters[key] == null || this.staticFieldFilters[key] == '' || this.staticFieldFilters[key] == 'undefined')) && this.staticFieldFilters[key] != 0 && delete this.staticFieldFilters[key]);\r\n\r\n\t\t\tObject.keys(this.fieldFilters).forEach((key) => {\r\n\t\t\t\tthis.filterPredicate = (data: TEntity, filter: string) => !filter || `${data[key]}`.toLowerCase().includes(`${this.filter}`?.toLowerCase());\r\n\t\t\t\tthis.filter = this.fieldFilters[key];\r\n\t\t\t});\r\n\t\t});\r\n\r\n\t\treturn super.connect();\r\n\t}\r\n\r\n\t/**\r\n\t * Clears field filters\r\n\t */\r\n\tpublic clearFilters(newFilters: any = {}): void {\r\n\t\tif (this.paginator) {\r\n\t\t\tthis.paginator.pageIndex = 0;\r\n\t\t}\r\n\r\n\t\tthis.fieldFilters = newFilters || {};\r\n\t\tthis.filter = '';\r\n\t\tthis.reload();\r\n\t}\r\n\r\n\t/**\r\n\t * Checks, whether all items are selected\r\n\t */\r\n\tpublic isAllSelected(): boolean {\r\n\t\tif (this.selectionModel.isEmpty()) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\treturn this.selectionModel.selected.length === this.paginator?.length;\r\n\t}\r\n\r\n\t/**\r\n\t * Toggles selected items\r\n\t * @param checkbox \r\n\t * @param predicate\r\n\t */\r\n\tpublic toggleSelect(checkbox: MatCheckboxChange, predicate?: (value: TEntity, index: number, array: TEntity[]) => unknown) {\r\n\t\tif (this.selectionModel.hasValue()) {\r\n\t\t\tthis.selectionModel.clear();\r\n\t\t\tcheckbox.source.checked = false;\r\n\t\t} else {\r\n\t\t\tthis.data.filter(predicate ? predicate : x => x)\r\n\t\t\t\t.filter(x => !x['locked'])\r\n\t\t\t\t.forEach(data => this.selectionModel.select(data['id']));\r\n\r\n\t\t\tif (this.selectionModel.selected.length !== this.paginator?.length) {\r\n\t\t\t\tcheckbox.source.checked = false;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Get selected Items\r\n\t */\r\n\tpublic getSelected(): number[] {\r\n\t\treturn this.selectionModel.selected;\r\n\t}\r\n}"]}

package/esm2020/messaia-cdk.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FpYS1jZGsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9jZGsvc3JjL21lc3NhaWEtY2RrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=