@messaia/cdk 0.0.0-CDK

package/esm2020/lib/table/components/filter-select.component.mjs

@@ -0,0 +1,334 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { TemplatePortalDirective } from '@angular/cdk/portal';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Component, ContentChild, Directive, ElementRef, forwardRef, Injector, Input, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatSelect } from '@angular/material/select';
+import { MatTable } from '@angular/material/table';
+import { BehaviorSubject } from 'rxjs';
+import { EnumService } from '../../common/services/enum.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/table";
+import * as i2 from "@angular/cdk/table";
+import * as i3 from "@angular/material/form-field";
+import * as i4 from "@angular/material/select";
+import * as i5 from "@angular/material/core";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/common";
+export class VdFilterOptionDirective extends TemplatePortalDirective {
+    constructor(templateRef, viewContainerRef) {
+        super(templateRef, viewContainerRef);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ VdFilterOptionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFilterOptionDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ VdFilterOptionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: VdFilterOptionDirective, selector: "[vd-filter-option]ng-template", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFilterOptionDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[vd-filter-option]ng-template' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; } });
+export class FilterSelectComponent {
+    /**
+     * Constructor
+     * @param injector
+     * @param table
+     * @param column
+     */
+    constructor(injector, table, column) {
+        this.injector = injector;
+        this.table = table;
+        this.column = column;
+        /**
+         * Represents a value that changes over time.
+         * Observers can subscribe to the subject to receive pdf file changes
+         */
+        this._endpointChange = new BehaviorSubject(null);
+        /**
+         * _params: any
+         */
+        this._params = {};
+        /**
+         * Sorts options
+         */
+        this._sorted = true;
+        /**
+         * The key
+         */
+        this.key = 'id';
+        /**
+         * The text
+         */
+        this.text = 'name';
+        /**
+         * The prefix
+         */
+        this.prefix = '';
+        /**
+         * multiple?
+         */
+        this.multiple = false;
+        /**
+         * filterable?
+         */
+        this.filterable = true;
+        /**
+         * Field name
+         */
+        this.field = '';
+        /**
+         * placeholder?: string
+         * Placeholder for the underlying input component.
+         */
+        this.placeholder = 'Filter...';
+        /**
+         * cache?
+         */
+        this.cache = true;
+        /**
+         * The http service from to get the data
+         */
+        this.http = null;
+        /**
+         * Called when the control receives a change event.
+         */
+        this.onChange = (_) => { };
+        /**
+         * Called when the control receives a touch event.
+         */
+        this.onTouched = () => { };
+        this.field = this.column.name.replace('filter.', '');
+        if (!this.enum) {
+            this.http = injector.get(HttpClient);
+        }
+    }
+    /**
+     * Gets pdf endpoint
+     */
+    get endpoint() { return this._endpointChange.value; }
+    /**
+     * Sets pdf endpoint
+     */
+    set endpoint(endpoint) { this._endpointChange.next(Array.isArray(endpoint) ? endpoint.join('') : endpoint); }
+    /**
+     * params: any
+     */
+    get params() { return this._params; }
+    set params(query) {
+        this._params = query;
+        /* Remove empty params */
+        Object.keys(this._params).forEach((key) => {
+            if ((this._params[key] == null || this._params[key] == '' || this._params[key] == 'undefined')) {
+                delete this._params[key];
+            }
+        });
+        this._endpointChange.next([this.endpoint, this.params, this.projection]);
+    }
+    /**
+     * projection: any
+     */
+    get projection() { return this._projection; }
+    set projection(projection) {
+        this._projection = projection;
+        this._endpointChange.next([this.endpoint, this.params, this.projection]);
+    }
+    /**
+     * Sorts options
+     */
+    get sorted() { return this._sorted; }
+    set sorted(multi) {
+        this._sorted = coerceBooleanProperty(multi);
+        this._endpointChange.next([this.endpoint, this.params, this.projection]);
+    }
+    /**
+     * Option list
+     */
+    get options() { return this._options; }
+    set options(value) {
+        this.filteredOptions = this._options = value;
+    }
+    /**
+     * Setters and getters for the select value
+     */
+    get value() { return this.table.dataSource['fieldFilters'][this.field]; }
+    ;
+    set value(v) {
+        if (v != this.table.dataSource['fieldFilters'][this.field]) {
+            this.table.dataSource['fieldFilters'][this.field] = v;
+            this.table.dataSource['paginator']['pageIndex'] = 0;
+            this.table.dataSource['reload']();
+            this.onChange(v);
+        }
+    }
+    /**
+     * Lifecycle hook that is called after data-bound properties of a directive are initialized.
+     */
+    ngOnInit() {
+        if (this.enum) {
+            this.options = EnumService.toArray(this.enum, this.prefix);
+            this.filterable = false;
+        }
+        else if (this.endpoint) {
+            this._endpointChange.subscribe((endpoint) => {
+                let headers = new HttpHeaders();
+                if (this.cache) {
+                    headers.set('Client-Cache', 'Yes');
+                }
+                /* Init params, if null */
+                this._params || (this._params = {});
+                /* Add projection, if any */
+                if (this.projection) {
+                    this._params.projection = this.projection;
+                }
+                /* Add sorting */
+                var url = new URLSearchParams(this.endpoint);
+                if (!this._params.sortBy && !url.has('sortBy') && (this.sortBy || this.sorted)) {
+                    this._params.sortBy = this.sortBy || this.text;
+                }
+                this.http.get(this.endpoint, { params: this._params, headers: headers }).subscribe(x => {
+                    this.options = x;
+                });
+            });
+        }
+    }
+    /**
+     * A callback method that is invoked immediately after
+     * Angular has completed initialization of a component's view.
+     * It is invoked only once when the view is instantiated.
+     *
+     */
+    ngAfterViewInit() {
+        this.selectEl?.openedChange?.subscribe(x => {
+            if (x && this.filterable) {
+                this.filterInput?.nativeElement.focus();
+            }
+        });
+    }
+    /**
+     * Write a new value to the element.
+     */
+    writeValue(value) {
+        this.value = value;
+        this.onChange(value);
+    }
+    /**
+     * Handels filter event
+     * @param searchText
+     */
+    handleFilter(searchText) {
+        searchText = searchText.toLowerCase();
+        this.filteredOptions = this.options.filter((x) => x[this.text]?.toLowerCase().search(searchText) > -1);
+    }
+    /**
+     * Set the function to be called when the control receives a change event.
+     */
+    registerOnChange(fn) { this.onChange = fn; }
+    /**
+     * Set the function to be called when the control receives a touch event.
+     */
+    registerOnTouched(fn) { this.onTouched = fn; }
+}
+/** @nocollapse */ /** @nocollapse */ FilterSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FilterSelectComponent, deps: [{ token: i0.Injector }, { token: i1.MatTable }, { token: i2.CdkColumnDef }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ FilterSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: FilterSelectComponent, selector: "mat-header-cell[filter-select],[mat-header-cell][filter-select]", inputs: { endpoint: "endpoint", params: "params", projection: "projection", sortBy: "sortBy", sorted: "sorted", enum: "enum", key: "key", text: "text", prefix: "prefix", multiple: "multiple", options: "options", filteredOptions: "filteredOptions", filterable: "filterable", field: "field", placeholder: "placeholder", cache: "cache" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => FilterSelectComponent)),
+            multi: true
+        }
+    ], queries: [{ propertyName: "optionTemplate", first: true, predicate: VdFilterOptionDirective, descendants: true }], viewQueries: [{ propertyName: "selectEl", first: true, predicate: MatSelect, descendants: true }, { propertyName: "filterInput", first: true, predicate: ["filterInput"], descendants: true }], ngImport: i0, template: `
+		<mat-form-field flex>
+			<mat-select type="input" [(ngModel)]="value" [multiple]="multiple" [placeholder]="placeholder">
+				<input #filterInput *ngIf="filterable" type="text" placeholder="Filter..." class="vd-select-filter" (keyup)="handleFilter($event.target?.value)">
+				<mat-option *ngIf="!multiple" class="tc-grey-500"></mat-option>
+				<ng-template let-option let-first="first" ngFor [ngForOf]="filteredOptions">
+					<mat-option [value]="option[key]">
+						<span *ngIf="!optionTemplate?.templateRef" i18n="@@selection">{option.name, select, option {option} other {{{option[text]}}}}</span>
+						<ng-template *ngIf="optionTemplate?.templateRef" [ngTemplateOutlet]="optionTemplate.templateRef" [ngTemplateOutletContext]="{ option: option }"></ng-template>
+					</mat-option>
+				</ng-template>
+			</mat-select>
+		</mat-form-field>`, isInline: true, styles: [".vd-select-filter{position:sticky;top:0;z-index:100;font-size:inherit;box-shadow:none;border-radius:0;padding:11px 16px;box-sizing:border-box;border:none;border-bottom:1px solid #dcdcdc;width:100%;background-color:#f5f5f5;outline:none}\n"], components: [{ type: i3.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i4.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { type: i5.MatOption, selector: "mat-option", exportAs: ["matOption"] }], directives: [{ type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FilterSelectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mat-header-cell[filter-select],[mat-header-cell][filter-select]',
+                    template: `
+		<mat-form-field flex>
+			<mat-select type="input" [(ngModel)]="value" [multiple]="multiple" [placeholder]="placeholder">
+				<input #filterInput *ngIf="filterable" type="text" placeholder="Filter..." class="vd-select-filter" (keyup)="handleFilter($event.target?.value)">
+				<mat-option *ngIf="!multiple" class="tc-grey-500"></mat-option>
+				<ng-template let-option let-first="first" ngFor [ngForOf]="filteredOptions">
+					<mat-option [value]="option[key]">
+						<span *ngIf="!optionTemplate?.templateRef" i18n="@@selection">{option.name, select, option {option} other {{{option[text]}}}}</span>
+						<ng-template *ngIf="optionTemplate?.templateRef" [ngTemplateOutlet]="optionTemplate.templateRef" [ngTemplateOutletContext]="{ option: option }"></ng-template>
+					</mat-option>
+				</ng-template>
+			</mat-select>
+		</mat-form-field>`,
+                    styles: [`
+		.vd-select-filter {
+			position: sticky;
+			top: 0;
+			z-index: 100;
+			font-size: inherit;
+			box-shadow: none;
+			border-radius: 0;
+			padding: 11px 16px;
+			box-sizing: border-box;
+			border: none;
+			border-bottom: 1px solid #dcdcdc;
+			width: 100%;
+			background-color: #f5f5f5;
+			outline: none;
+		}`
+                    ],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => FilterSelectComponent)),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.MatTable }, { type: i2.CdkColumnDef }]; }, propDecorators: { optionTemplate: [{
+                type: ContentChild,
+                args: [VdFilterOptionDirective]
+            }], selectEl: [{
+                type: ViewChild,
+                args: [MatSelect, { static: false }]
+            }], filterInput: [{
+                type: ViewChild,
+                args: ['filterInput', { static: false }]
+            }], endpoint: [{
+                type: Input
+            }], params: [{
+                type: Input
+            }], projection: [{
+                type: Input
+            }], sortBy: [{
+                type: Input
+            }], sorted: [{
+                type: Input
+            }], enum: [{
+                type: Input
+            }], key: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], prefix: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], filteredOptions: [{
+                type: Input
+            }], filterable: [{
+                type: Input
+            }], field: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], cache: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-select.component.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/table/components/filter-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { TemplatePortalDirective } from '@angular/cdk/portal';\r\nimport { CdkColumnDef } from '@angular/cdk/table';\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Component, ContentChild, Directive, ElementRef, forwardRef, Injector, Input, OnInit, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { MatSelect } from '@angular/material/select';\r\nimport { MatTable } from '@angular/material/table';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { EnumService } from '../../common/services/enum.service';\r\n\r\n@Directive({ selector: '[vd-filter-option]ng-template' })\r\nexport class VdFilterOptionDirective extends TemplatePortalDirective {\r\n\tconstructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef) {\r\n\t\tsuper(templateRef, viewContainerRef);\r\n\t}\r\n}\r\n\r\n@Component({\r\n\tselector: 'mat-header-cell[filter-select],[mat-header-cell][filter-select]',\r\n\ttemplate: `\r\n\t\t<mat-form-field flex>\r\n\t\t\t<mat-select type=\"input\" [(ngModel)]=\"value\" [multiple]=\"multiple\" [placeholder]=\"placeholder\">\r\n\t\t\t\t<input #filterInput *ngIf=\"filterable\" type=\"text\" placeholder=\"Filter...\" class=\"vd-select-filter\" (keyup)=\"handleFilter($event.target?.value)\">\r\n\t\t\t\t<mat-option *ngIf=\"!multiple\" class=\"tc-grey-500\"></mat-option>\r\n\t\t\t\t<ng-template let-option let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n\t\t\t\t\t<mat-option [value]=\"option[key]\">\r\n\t\t\t\t\t\t<span *ngIf=\"!optionTemplate?.templateRef\" i18n=\"@@selection\">{option.name, select, option {option} other {{{option[text]}}}}</span>\r\n\t\t\t\t\t\t<ng-template *ngIf=\"optionTemplate?.templateRef\" [ngTemplateOutlet]=\"optionTemplate.templateRef\" [ngTemplateOutletContext]=\"{ option: option }\"></ng-template>\r\n\t\t\t\t\t</mat-option>\r\n\t\t\t\t</ng-template>\r\n\t\t\t</mat-select>\r\n\t\t</mat-form-field>`,\r\n\tstyles: [`\r\n\t\t.vd-select-filter {\r\n\t\t\tposition: sticky;\r\n\t\t\ttop: 0;\r\n\t\t\tz-index: 100;\r\n\t\t\tfont-size: inherit;\r\n\t\t\tbox-shadow: none;\r\n\t\t\tborder-radius: 0;\r\n\t\t\tpadding: 11px 16px;\r\n\t\t\tbox-sizing: border-box;\r\n\t\t\tborder: none;\r\n\t\t\tborder-bottom: 1px solid #dcdcdc;\r\n\t\t\twidth: 100%;\r\n\t\t\tbackground-color: #f5f5f5;\r\n\t\t\toutline: none;\r\n\t\t}`\r\n\t],\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: NG_VALUE_ACCESSOR,\r\n\t\t\tuseExisting: forwardRef(() => FilterSelectComponent),\r\n\t\t\tmulti: true\r\n\t\t}\r\n\t]\r\n})\r\nexport class FilterSelectComponent implements OnInit, ControlValueAccessor {\r\n\t/**\r\n\t * VdChip template\r\n\t */\r\n\t@ContentChild(VdFilterOptionDirective)\r\n\tpublic optionTemplate: VdFilterOptionDirective;\r\n\r\n\t/** \r\n\t * The select element.\r\n\t */\r\n\t@ViewChild(MatSelect, { static: false })\r\n\tpublic selectEl: MatSelect;\r\n\r\n\t/** \r\n\t * The select element.\r\n\t */\r\n\t@ViewChild('filterInput', { static: false })\r\n\tpublic filterInput: ElementRef;\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 pdf file changes\r\n\t */\r\n\tprivate _endpointChange = new BehaviorSubject(null);\r\n\r\n\t/**\r\n\t * Gets pdf endpoint\r\n\t */\r\n\tget endpoint(): any { return this._endpointChange.value; }\r\n\r\n\t/**\r\n\t * Sets pdf endpoint\r\n\t */\r\n\t@Input()\r\n\tset endpoint(endpoint: any) { this._endpointChange.next(Array.isArray(endpoint) ? endpoint.join('') : endpoint); }\r\n\r\n\t/**\r\n\t * _params: any\r\n\t */\r\n\tpublic _params: any = {};\r\n\r\n\t/**\r\n\t * params: any\r\n\t */\r\n\t@Input()\r\n\tget params() { return this._params; }\r\n\tset params(query: any) {\r\n\t\tthis._params = query;\r\n\r\n\t\t/* Remove empty params */\r\n\t\tObject.keys(this._params).forEach((key) => {\r\n\t\t\tif ((this._params[key] == null || this._params[key] == '' || this._params[key] == 'undefined')) {\r\n\t\t\t\tdelete this._params[key];\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tthis._endpointChange.next([this.endpoint, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * _projection: any\r\n\t */\r\n\tpublic _projection: string;\r\n\r\n\t/**\r\n\t * projection: any\r\n\t */\r\n\t@Input()\r\n\tget projection() { return this._projection; }\r\n\tset projection(projection: string) {\r\n\t\tthis._projection = projection;\r\n\t\tthis._endpointChange.next([this.endpoint, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * sortBy?\r\n\t */\r\n\t@Input()\r\n\tpublic sortBy: string;\r\n\r\n\t/**\r\n\t * Sorts options\r\n\t */\r\n\tpublic _sorted: boolean = true;\r\n\r\n\t/**\r\n\t * Sorts options\r\n\t */\r\n\t@Input()\r\n\tget sorted() { return this._sorted; }\r\n\tset sorted(multi) {\r\n\t\tthis._sorted = coerceBooleanProperty(multi);\r\n\t\tthis._endpointChange.next([this.endpoint, this.params, this.projection]);\r\n\t}\r\n\r\n\t/**\r\n\t * The name of the endpoint\r\n\t */\r\n\t@Input()\r\n\tprivate enum: any;\r\n\r\n\t/**\r\n\t * The key\r\n\t */\r\n\t@Input()\r\n\tpublic key: any = 'id';\r\n\r\n\t/**\r\n\t * The text\r\n\t */\r\n\t@Input()\r\n\tpublic text: any = 'name';\r\n\r\n\t/**\r\n\t * The prefix\r\n\t */\r\n\t@Input()\r\n\tpublic prefix: any = '';\r\n\r\n\t/**\r\n\t * multiple?\r\n\t */\r\n\t@Input()\r\n\tpublic multiple: boolean = false;\r\n\r\n\t/**\r\n\t * Option list\r\n\t */\r\n\tpublic _options: any;\r\n\r\n\t/**\r\n\t * Option list\r\n\t */\r\n\t@Input()\r\n\tget options() { return this._options; }\r\n\tset options(value) {\r\n\t\tthis.filteredOptions = this._options = value;\r\n\t}\r\n\t/**\r\n\t * filtered option list\r\n\t */\r\n\t@Input()\r\n\tpublic filteredOptions: any;\r\n\r\n\t/**\r\n\t * filterable?\r\n\t */\r\n\t@Input()\r\n\tpublic filterable: boolean = true;\r\n\r\n\t/**\r\n\t * Field name\r\n\t */\r\n\t@Input() field: string = '';\r\n\r\n\t/**\r\n\t * placeholder?: string\r\n\t * Placeholder for the underlying input component.\r\n\t */\r\n\t@Input() placeholder: string = 'Filter...';\r\n\r\n\t/**\r\n\t * cache?\r\n\t */\r\n\t@Input()\r\n\tpublic cache: boolean = true;\r\n\r\n\t/**\r\n\t * The http service from to get the data\r\n\t */\r\n\tprotected http: HttpClient = null;\r\n\r\n\t/**\r\n\t * Setters and getters for the select value\r\n\t */\r\n\tget value(): any { return this.table.dataSource['fieldFilters'][this.field]; };\r\n\tset value(v: any) {\r\n\t\tif (v != this.table.dataSource['fieldFilters'][this.field]) {\r\n\t\t\tthis.table.dataSource['fieldFilters'][this.field] = v;\r\n\t\t\tthis.table.dataSource['paginator']['pageIndex'] = 0;\r\n\t\t\tthis.table.dataSource['reload']();\r\n\t\t\tthis.onChange(v);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param injector\r\n\t * @param table \r\n\t * @param column\r\n\t */\r\n\tconstructor(private injector: Injector, private table: MatTable<any>, private column: CdkColumnDef) {\r\n\t\tthis.field = this.column.name.replace('filter.', '');\r\n\r\n\t\tif (!this.enum) {\r\n\t\t\tthis.http = injector.get(HttpClient);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Lifecycle hook that is called after data-bound properties of a directive are initialized.\r\n\t */\r\n\tngOnInit() {\r\n\t\tif (this.enum) {\r\n\t\t\tthis.options = EnumService.toArray(this.enum, this.prefix);\r\n\t\t\tthis.filterable = false;\r\n\t\t} else if (this.endpoint) {\r\n\t\t\tthis._endpointChange.subscribe((endpoint: string) => {\r\n\t\t\t\tlet headers = new HttpHeaders();\r\n\t\t\t\tif (this.cache) {\r\n\t\t\t\t\theaders.set('Client-Cache', 'Yes');\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Init params, if null */\r\n\t\t\t\tthis._params ||= {};\r\n\r\n\t\t\t\t/* Add projection, if any */\r\n\t\t\t\tif (this.projection) {\r\n\t\t\t\t\tthis._params.projection = this.projection;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Add sorting */\r\n\t\t\t\tvar url = new URLSearchParams(this.endpoint);\r\n\t\t\t\tif (!this._params.sortBy && !url.has('sortBy') && (this.sortBy || this.sorted)) {\r\n\t\t\t\t\tthis._params.sortBy = this.sortBy || this.text;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tthis.http.get(this.endpoint, { params: this._params, headers: headers }).subscribe(x => {\r\n\t\t\t\t\tthis.options = x;\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * A callback method that is invoked immediately after\r\n\t * Angular has completed initialization of a component's view.\r\n\t * It is invoked only once when the view is instantiated.\r\n\t *\r\n\t */\r\n\tngAfterViewInit(): void {\r\n\t\tthis.selectEl?.openedChange?.subscribe(x => {\r\n\t\t\tif (x && this.filterable) {\r\n\t\t\t\tthis.filterInput?.nativeElement.focus();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Write a new value to the element.\r\n\t */\r\n\twriteValue(value: any) {\r\n\t\tthis.value = value;\r\n\t\tthis.onChange(value);\r\n\t}\r\n\r\n\t/**\r\n\t * Handels filter event\r\n\t * @param searchText \r\n\t */\r\n\tpublic handleFilter(searchText: string): void {\r\n\t\tsearchText = searchText.toLowerCase();\r\n\t\tthis.filteredOptions = this.options.filter((x: any) => x[this.text]?.toLowerCase().search(searchText) > -1);\r\n\t}\r\n\r\n\t/**\r\n\t * Set the function to be called when the control receives a change event.\r\n\t */\r\n\tregisterOnChange(fn: (_: any) => void): void { this.onChange = fn; }\r\n\r\n\t/**\r\n\t * Set the function to be called when the control receives a touch event.\r\n\t */\r\n\tregisterOnTouched(fn: () => void): void { this.onTouched = fn; }\r\n\r\n\t/**\r\n\t * Called when the control receives a change event.\r\n\t */\r\n\tonChange = (_) => { };\r\n\r\n\t/**\r\n\t * Called when the control receives a touch event.\r\n\t */\r\n\tonTouched = () => { };\r\n}"]}

package/esm2020/lib/table/directives/data-source-filter.directive.mjs

@@ -0,0 +1,45 @@
+import { Directive, Input } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { TableDataSource } from '../table.data-source';
+import * as i0 from "@angular/core";
+export class DataSourceFilterDirective {
+    constructor() {
+        /**
+         * Represents a value that changes over time.
+         * Observers can subscribe to the subject to receive filter changes
+         */
+        this._queryChange = new BehaviorSubject(null);
+    }
+    /**
+     * Sets query
+     */
+    set dataSourceFilter(query) { this._queryChange.next(query); }
+    /**
+     * Gets query
+     */
+    get dataSourceFilter() { return this._queryChange.value; }
+    /**
+     * Lifecycle hook that is called after data-bound properties of a directive are initialized.
+     */
+    ngOnInit() {
+        this._queryChange.subscribe(() => {
+            /* Update the filters */
+            Object.assign(this.dataSource.staticFieldFilters || {}, this.dataSourceFilter != null ? this.dataSourceFilter : {});
+            /* Reload data */
+            this.dataSource.reload();
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DataSourceFilterDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DataSourceFilterDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ DataSourceFilterDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: DataSourceFilterDirective, selector: "[dataSourceFilter]", inputs: { dataSource: "dataSource", dataSourceFilter: "dataSourceFilter" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DataSourceFilterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dataSourceFilter]'
+                }]
+        }], propDecorators: { dataSource: [{
+                type: Input
+            }], dataSourceFilter: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/table/enums/table-column-type.mjs

@@ -0,0 +1,14 @@
+export var TableColumnType;
+(function (TableColumnType) {
+    TableColumnType[TableColumnType["None"] = 0] = "None";
+    TableColumnType[TableColumnType["Checkbox"] = 1] = "Checkbox";
+    TableColumnType[TableColumnType["Text"] = 2] = "Text";
+    TableColumnType[TableColumnType["TextInput"] = 3] = "TextInput";
+    TableColumnType[TableColumnType["Number"] = 4] = "Number";
+    TableColumnType[TableColumnType["Select"] = 5] = "Select";
+    TableColumnType[TableColumnType["Enum"] = 6] = "Enum";
+    TableColumnType[TableColumnType["Toggle"] = 7] = "Toggle";
+    TableColumnType[TableColumnType["Date"] = 8] = "Date";
+    TableColumnType[TableColumnType["Action"] = 9] = "Action";
+})(TableColumnType || (TableColumnType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtY29sdW1uLXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvc3JjL2xpYi90YWJsZS9lbnVtcy90YWJsZS1jb2x1bW4tdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxlQVdYO0FBWEQsV0FBWSxlQUFlO0lBQ3ZCLHFEQUFJLENBQUE7SUFDSiw2REFBUSxDQUFBO0lBQ1IscURBQUksQ0FBQTtJQUNKLCtEQUFTLENBQUE7SUFDVCx5REFBTSxDQUFBO0lBQ04seURBQU0sQ0FBQTtJQUNOLHFEQUFJLENBQUE7SUFDSix5REFBTSxDQUFBO0lBQ04scURBQUksQ0FBQTtJQUNKLHlEQUFNLENBQUE7QUFDVixDQUFDLEVBWFcsZUFBZSxLQUFmLGVBQWUsUUFXMUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBUYWJsZUNvbHVtblR5cGUge1xyXG4gICAgTm9uZSxcclxuICAgIENoZWNrYm94LFxyXG4gICAgVGV4dCxcclxuICAgIFRleHRJbnB1dCxcclxuICAgIE51bWJlcixcclxuICAgIFNlbGVjdCxcclxuICAgIEVudW0sXHJcbiAgICBUb2dnbGUsXHJcbiAgICBEYXRlLFxyXG4gICAgQWN0aW9uXHJcbn0iXX0=

package/esm2020/lib/table/functions/decorators.mjs

@@ -0,0 +1,135 @@
+import "reflect-metadata";
+import { headerMetadataKey } from "../../common/constants/constants";
+import { Utils } from "../../common/functions/utils";
+import { TableColumnType } from "../enums/table-column-type";
+import { TableColumn } from "../models/table-column";
+import { TableDefinition } from "../models/table-definition";
+export const tableMetadataKey = Symbol('vdTable');
+export const columnMetadataKey = Symbol('vdTableColumn');
+let indexes = {};
+/**
+ * Class decorator to create a mat-table
+ * @param args
+ * @returns
+ */
+export function Table(tableDefinition) {
+    return function (target) {
+        if (Object.getOwnPropertyDescriptor(target.prototype, 'tableDefinition') == null) {
+            target.prototype.tableDefinition = tableDefinition;
+        }
+        else {
+            target.prototype.tableDefinition = Object.assign(target.prototype.tableDefinition || {}, tableDefinition);
+        }
+        /* Add action menus from table definition, if any */
+        let pTableDefinition = target.prototype.tableDefinition;
+        var actions = pTableDefinition.actions;
+        if (actions?.length > 0 && pTableDefinition.columns?.length > 0) {
+            var actionColmun = pTableDefinition.columns?.find(x => x.name == 'action');
+            if (actionColmun != null) {
+                actionColmun.rowMenuItems = actionColmun.rowMenuItems || [];
+                actions.forEach(y => actionColmun.rowMenuItems.push(y));
+            }
+            else {
+                pTableDefinition.columns.push(new TableColumn({
+                    index: 2000,
+                    name: 'action',
+                    type: TableColumnType.Action,
+                    disabled: true,
+                    rowMenuItems: actions
+                }));
+            }
+        }
+        /* Set endpoint */
+        target.prototype.endpoint = pTableDefinition.endpoint || target.prototype.endpoint;
+    };
+}
+/**
+ * Property decorator to create table columns
+ * @param args
+ * @returns
+ */
+export function Column(args) {
+    return function (target, propertyKey) {
+        /* Init args */
+        args = Object.assign(args || {}, new TableColumn());
+        /* Get property name */
+        var propertyName = args.name || propertyKey;
+        /* Get property type */
+        var propertyType = Reflect.getMetadata("design:type", target, propertyKey)?.name;
+        /* Init index */
+        indexes[target.endpoint] = indexes[target.endpoint] || 0;
+        /* Create table column */
+        var tableColumn = new TableColumn(Object.assign(args, {
+            name: args.name || propertyKey,
+            header: args.header || Reflect.getMetadata(headerMetadataKey, target, propertyKey) || propertyName,
+            filter: args.filter || propertyKey,
+            content: args.content ? args.content : (row) => {
+                /* Get content using property name */
+                var content = Utils.getPropertyValue(row, propertyName);
+                /* Truncate the text if content length is specified */
+                if (tableColumn.contentLength > 0) {
+                    return Utils.truncateText(content, tableColumn.contentLength);
+                }
+                return content;
+            },
+            index: args.index || (indexes[target.endpoint]++)
+        }));
+        /* Set type to enum, if enum type is specified */
+        if (tableColumn.enumType) {
+            tableColumn.type || (tableColumn.type = TableColumnType.Enum);
+        }
+        /* Set type to 'Select' if endpoint is specified */
+        else if (tableColumn.endpoint || tableColumn.options) {
+            tableColumn.type || (tableColumn.type = TableColumnType.Select);
+        }
+        /* Otherwiese, set type depending on property type */
+        else {
+            switch (propertyType.toLowerCase()) {
+                case 'number':
+                    tableColumn.inputType || (tableColumn.inputType = 'number');
+                    tableColumn.type || (tableColumn.type = TableColumnType.Number);
+                    break;
+                case 'date':
+                    tableColumn.inputType || (tableColumn.inputType = 'date');
+                    tableColumn.type || (tableColumn.type = TableColumnType.Date);
+                    tableColumn.maxWidth || (tableColumn.maxWidth = 80);
+                    tableColumn.arrowBefore = tableColumn.arrowBefore !== undefined ? tableColumn.arrowBefore : true;
+                    if (!tableColumn.showGtXs && !tableColumn.showGtMd && !tableColumn.showGtLg && !tableColumn.showGtXl) {
+                        tableColumn.showGtSm = true;
+                    }
+                    break;
+                case 'boolean':
+                    tableColumn.type || (tableColumn.type = TableColumnType.Toggle);
+                    tableColumn.options || (tableColumn.options = [{ id: false, name: $localize `:@@no:No` }, { id: true, name: $localize `:@@yes:Yes` }]);
+                    tableColumn.maxWidth || (tableColumn.maxWidth = 70);
+                    if (!tableColumn.showGtXs && !tableColumn.showGtMd && !tableColumn.showGtLg && !tableColumn.showGtXl) {
+                        tableColumn.showGtSm = true;
+                    }
+                    break;
+                default:
+                    tableColumn.type || (tableColumn.type = TableColumnType.Text);
+                    break;
+            }
+        }
+        if (tableColumn.maxWidth) {
+            tableColumn.width || (tableColumn.width = tableColumn.maxWidth);
+        }
+        /* Gets the own property descriptor of the specified object */
+        if (Object.getOwnPropertyDescriptor(target, 'tableDefinition') == null) {
+            target.tableDefinition = new TableDefinition();
+        }
+        /* Add the column to the list */
+        target.tableDefinition.columns.push(tableColumn);
+        /* Sort the columns by index */
+        Utils.sortArray(target.tableDefinition.columns, 'index');
+        /* Since target is now specific to, append properties defined in parent */
+        let parentTarget = Object.getPrototypeOf(target);
+        /* Add parent columns */
+        parentTarget?.tableDefinition?.columns?.forEach((column) => {
+            if (target.tableDefinition.columns.find((x) => x.name.trim() == column.name.trim()) == null) {
+                target.tableDefinition.columns.push(column);
+            }
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/table/functions/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import \"reflect-metadata\";\r\nimport { headerMetadataKey } from \"../../common/constants/constants\";\r\nimport { Utils } from \"../../common/functions/utils\";\r\nimport { TableColumnType } from \"../enums/table-column-type\";\r\nimport { TableColumn } from \"../models/table-column\";\r\nimport { TableDefinition } from \"../models/table-definition\";\r\n\r\nexport const tableMetadataKey = Symbol('vdTable');\r\nexport const columnMetadataKey = Symbol('vdTableColumn');\r\n\r\nlet indexes: any = {};\r\n\r\n/**\r\n * Class decorator to create a mat-table\r\n * @param args \r\n * @returns \r\n */\r\nexport function Table(tableDefinition?: Partial<TableDefinition>): Function {\r\n    return function (target: Function) {\r\n        if (Object.getOwnPropertyDescriptor(target.prototype, 'tableDefinition') == null) {\r\n            target.prototype.tableDefinition = tableDefinition;\r\n        } else {\r\n            target.prototype.tableDefinition = Object.assign(target.prototype.tableDefinition || {}, tableDefinition);\r\n        }\r\n\r\n        /* Add action menus from table definition, if any */\r\n        let pTableDefinition = (target.prototype.tableDefinition as TableDefinition);\r\n        var actions = pTableDefinition.actions;\r\n        if (actions?.length > 0 && pTableDefinition.columns?.length > 0) {\r\n            var actionColmun = pTableDefinition.columns?.find(x => x.name == 'action');\r\n            if (actionColmun != null) {\r\n                actionColmun.rowMenuItems = actionColmun.rowMenuItems || [];\r\n                actions.forEach(y => actionColmun.rowMenuItems.push(y));\r\n            } else {\r\n                pTableDefinition.columns.push(new TableColumn({\r\n                    index: 2000,\r\n                    name: 'action',\r\n                    type: TableColumnType.Action,\r\n                    disabled: true,\r\n                    rowMenuItems: actions\r\n                }));\r\n            }\r\n        }\r\n\r\n        /* Set endpoint */\r\n        target.prototype.endpoint = pTableDefinition.endpoint || target.prototype.endpoint;\r\n    };\r\n}\r\n\r\n/**\r\n * Property decorator to create table columns\r\n * @param args \r\n * @returns \r\n */\r\nexport function Column(args?: Partial<TableColumn>): Function {\r\n    return function (target: any, propertyKey: string) {\r\n        /* Init args */\r\n        args = Object.assign(args || {}, new TableColumn());\r\n\r\n        /* Get property name */\r\n        var propertyName = args.name || propertyKey;\r\n\r\n        /* Get property type */\r\n        var propertyType: string = Reflect.getMetadata(\"design:type\", target, propertyKey)?.name;\r\n\r\n        /* Init index */\r\n        indexes[target.endpoint] = indexes[target.endpoint] || 0;\r\n\r\n        /* Create table column */\r\n        var tableColumn = new TableColumn(Object.assign(args, <TableColumn>{\r\n            name: args.name || propertyKey,\r\n            header: args.header || Reflect.getMetadata(headerMetadataKey, target, propertyKey) || propertyName,\r\n            filter: args.filter || propertyKey,\r\n            content: args.content ? args.content : (row: any) => {\r\n                /* Get content using property name */\r\n                var content = Utils.getPropertyValue(row, propertyName);\r\n\r\n                /* Truncate the text if content length is specified */\r\n                if (tableColumn.contentLength > 0) {\r\n                    return Utils.truncateText(content, tableColumn.contentLength);\r\n                }\r\n\r\n                return content;\r\n            },\r\n            index: args.index || (indexes[target.endpoint]++)\r\n        }));\r\n\r\n        /* Set type to enum, if enum type is specified */\r\n        if (tableColumn.enumType) {\r\n            tableColumn.type ||= TableColumnType.Enum;\r\n        }\r\n\r\n        /* Set type to 'Select' if endpoint is specified */\r\n        else if (tableColumn.endpoint || tableColumn.options) {\r\n            tableColumn.type ||= TableColumnType.Select;\r\n        }\r\n\r\n        /* Otherwiese, set type depending on property type */\r\n        else {\r\n            switch (propertyType.toLowerCase()) {\r\n                case 'number':\r\n                    tableColumn.inputType ||= 'number';\r\n                    tableColumn.type ||= TableColumnType.Number;\r\n                    break;\r\n\r\n                case 'date':\r\n                    tableColumn.inputType ||= 'date';\r\n                    tableColumn.type ||= TableColumnType.Date;\r\n                    tableColumn.maxWidth ||= 80;\r\n                    tableColumn.arrowBefore = tableColumn.arrowBefore !== undefined ? tableColumn.arrowBefore : true;\r\n                    if (!tableColumn.showGtXs && !tableColumn.showGtMd && !tableColumn.showGtLg && !tableColumn.showGtXl) {\r\n                        tableColumn.showGtSm = true;\r\n                    }\r\n                    break;\r\n\r\n                case 'boolean':\r\n                    tableColumn.type ||= TableColumnType.Toggle;\r\n                    tableColumn.options ||= [{ id: false, name: $localize`:@@no:No` }, { id: true, name: $localize`:@@yes:Yes` }];\r\n                    tableColumn.maxWidth ||= 70;\r\n                    if (!tableColumn.showGtXs && !tableColumn.showGtMd && !tableColumn.showGtLg && !tableColumn.showGtXl) {\r\n                        tableColumn.showGtSm = true;\r\n                    }\r\n                    break;\r\n\r\n                default:\r\n                    tableColumn.type ||= TableColumnType.Text;\r\n                    break;\r\n            }\r\n        }\r\n\r\n        if (tableColumn.maxWidth) {\r\n            tableColumn.width ||= tableColumn.maxWidth;\r\n        }\r\n\r\n        /* Gets the own property descriptor of the specified object */\r\n        if (Object.getOwnPropertyDescriptor(target, 'tableDefinition') == null) {\r\n            target.tableDefinition = new TableDefinition();\r\n        }\r\n\r\n        /* Add the column to the list */\r\n        target.tableDefinition.columns.push(tableColumn);\r\n\r\n        /* Sort the columns by index */\r\n        Utils.sortArray(target.tableDefinition.columns, 'index');\r\n\r\n        /* Since target is now specific to, append properties defined in parent */\r\n        let parentTarget = Object.getPrototypeOf(target);\r\n\r\n        /* Add parent columns */\r\n        parentTarget?.tableDefinition?.columns?.forEach((column: TableColumn) => {\r\n            if (target.tableDefinition.columns.find((x: TableColumn) => x.name.trim() == column.name.trim()) == null) {\r\n                target.tableDefinition.columns.push(column);\r\n            }\r\n        });\r\n    };\r\n}"]}

package/esm2020/lib/table/functions/functions.mjs

@@ -0,0 +1,15 @@
+import "reflect-metadata";
+/**
+ * Gets classes decoarated with @Table
+ * @param origin
+ * @returns
+ */
+export function getTableDefinition(origin) {
+    let tableDefinition = origin['tableDefinition'];
+    if (tableDefinition?.columns) {
+        tableDefinition.columns = tableDefinition?.columns.filter(x => !x.hidden &&
+            !tableDefinition.hideColumns?.some(y => y.trim() == x.name.trim()));
+    }
+    return tableDefinition;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvdGFibGUvZnVuY3Rpb25zL2Z1bmN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLGtCQUFrQixDQUFDO0FBRzFCOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsa0JBQWtCLENBQUMsTUFBYztJQUM3QyxJQUFJLGVBQWUsR0FBRyxNQUFNLENBQUMsaUJBQWlCLENBQW9CLENBQUM7SUFDbkUsSUFBSSxlQUFlLEVBQUUsT0FBTyxFQUFFO1FBQzFCLGVBQWUsQ0FBQyxPQUFPLEdBQUcsZUFBZSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FDMUQsQ0FBQyxDQUFDLENBQUMsTUFBTTtZQUNULENBQUMsZUFBZSxDQUFDLFdBQVcsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUNyRSxDQUFDO0tBQ0w7SUFFRCxPQUFPLGVBQWUsQ0FBQztBQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFwicmVmbGVjdC1tZXRhZGF0YVwiO1xyXG5pbXBvcnQgeyBUYWJsZURlZmluaXRpb24gfSBmcm9tIFwiLi4vbW9kZWxzL3RhYmxlLWRlZmluaXRpb25cIjtcclxuXHJcbi8qKlxyXG4gKiBHZXRzIGNsYXNzZXMgZGVjb2FyYXRlZCB3aXRoIEBUYWJsZVxyXG4gKiBAcGFyYW0gb3JpZ2luIFxyXG4gKiBAcmV0dXJucyBcclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBnZXRUYWJsZURlZmluaXRpb24ob3JpZ2luOiBvYmplY3QpOiBUYWJsZURlZmluaXRpb24ge1xyXG4gICAgbGV0IHRhYmxlRGVmaW5pdGlvbiA9IG9yaWdpblsndGFibGVEZWZpbml0aW9uJ10gYXMgVGFibGVEZWZpbml0aW9uO1xyXG4gICAgaWYgKHRhYmxlRGVmaW5pdGlvbj8uY29sdW1ucykge1xyXG4gICAgICAgIHRhYmxlRGVmaW5pdGlvbi5jb2x1bW5zID0gdGFibGVEZWZpbml0aW9uPy5jb2x1bW5zLmZpbHRlcih4ID0+XHJcbiAgICAgICAgICAgICF4LmhpZGRlbiAmJlxyXG4gICAgICAgICAgICAhdGFibGVEZWZpbml0aW9uLmhpZGVDb2x1bW5zPy5zb21lKHkgPT4geS50cmltKCkgPT0geC5uYW1lLnRyaW0oKSlcclxuICAgICAgICApO1xyXG4gICAgfVxyXG5cclxuICAgIHJldHVybiB0YWJsZURlZmluaXRpb247XHJcbn0iXX0=

package/esm2020/lib/table/models/pagination.mjs

@@ -0,0 +1,3 @@
+export class Pagination {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL3RhYmxlL21vZGVscy9wYWdpbmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxVQUFVO0NBTXRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFBhZ2luYXRpb248VE1vZGVsPiB7XHJcblx0cGFnZTogbnVtYmVyO1xyXG5cdHBhZ2VTaXplOiBudW1iZXI7XHJcblx0cGFnZUNvdW50OiBudW1iZXI7XHJcblx0dG90YWw6IG51bWJlcjtcclxuXHRpdGVtczogVE1vZGVsW107XHJcbn0iXX0=