@messaia/cdk 18.0.0-rc13 → 18.0.0-rc14

package/esm2022/lib/table/components/dynamic-table/dynamic-table.component.mjs

@@ -37,7 +37,7 @@ import * as i18 from "@angular/material/slide-toggle";
 import * as i19 from "@angular/material/paginator";
 import * as i20 from "@angular/material/tooltip";
 import * as i21 from "../filter-input.component";
-import * as i22 from "../filter-select.component";
+import * as i22 from "../filter-select/filter-select.component";
 import * as i23 from "../filter-clear.component";
 import * as i24 from "../filter-date.component";
 import * as i25 from "../../directives/data-source-filter.directive";

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

@@ -0,0 +1,375 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { CdkPortal } from '@angular/cdk/portal';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Component, ContentChild, Directive, ElementRef, HostListener, Injector, Input, TemplateRef, ViewChild, ViewContainerRef, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MAT_SELECT_CONFIG, 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/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/select";
+import * as i7 from "@angular/material/core";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/input";
+export class VdFilterOptionDirective extends CdkPortal {
+    constructor(templateRef, viewContainerRef) {
+        super(templateRef, viewContainerRef);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VdFilterOptionDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.6", type: VdFilterOptionDirective, selector: "[vd-filter-option]ng-template", usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: VdFilterOptionDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[vd-filter-option]ng-template' }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }] });
+export class FilterSelectComponent {
+    injector;
+    table;
+    column;
+    /**
+     * VdChip template
+     */
+    optionTemplate;
+    /**
+     * The select element.
+     */
+    selectEl;
+    /**
+     * The select element.
+     */
+    filterInput;
+    /**
+     * Represents a value that changes over time.
+     * Observers can subscribe to the subject to receive pdf file changes
+     */
+    _endpointChange = new BehaviorSubject([]);
+    /**
+     * Represents a value that changes over time.
+     */
+    _enumChange = new BehaviorSubject([]);
+    /**
+     * 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
+     */
+    _params = {};
+    /**
+     * 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
+     */
+    _projection;
+    /**
+     * projection: any
+     */
+    get projection() { return this._projection; }
+    set projection(projection) {
+        this._projection = projection;
+        this._endpointChange.next([this.endpoint, this.params, this.projection]);
+    }
+    /**
+     * sortBy?
+     */
+    sortBy;
+    /**
+     * Sorts options
+     */
+    _sorted = true;
+    /**
+     * _enumFilter: Function
+     */
+    _enumFilter;
+    /**
+     * Sorts options
+     */
+    get sorted() { return this._sorted; }
+    set sorted(multi) {
+        this._sorted = coerceBooleanProperty(multi);
+        this._endpointChange.next([this.endpoint, this.params, this.projection]);
+    }
+    /**
+     * @property
+     */
+    get enumFilter() { return this._enumFilter; }
+    set enumFilter(enumFilter) { this._enumFilter = enumFilter; this._enumChange.next([this._enumFilter]); }
+    /**
+     * The name of the endpoint
+     */
+    enum;
+    /**
+     * Metadata for enum types.
+     * @property
+     */
+    enumMetadata;
+    /**
+     * The key
+     */
+    key = 'id';
+    /**
+     * The text
+     */
+    text = 'name';
+    /**
+     * The prefix
+     */
+    prefix = '';
+    /**
+     * multiple?
+     */
+    multiple = false;
+    /**
+     * Option list
+     */
+    _options;
+    /**
+     * Option list
+     */
+    get options() { return this._options; }
+    set options(value) {
+        this.filteredOptions = this._options = value;
+    }
+    /**
+     * filtered option list
+     */
+    filteredOptions;
+    /**
+     * filterable?
+     */
+    filterable = true;
+    /**
+     * Field name
+     */
+    field = '';
+    /**
+     * placeholder?: string
+     * Placeholder for the underlying input component.
+     */
+    placeholder = 'Filter...';
+    /**
+     * cache?
+     */
+    cache = true;
+    /**
+     * The http service from to get the data
+     */
+    http;
+    /**
+     * 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);
+        }
+    }
+    /**
+     * Whether the control is focused.
+     */
+    focused = false;
+    /**
+     * Whether the control is focused.
+     */
+    onFocusIn() { this.focused = true; }
+    onFocusOut() { this.focused = false; }
+    /**
+     * Constructor
+     * @param injector
+     * @param table
+     * @param column
+     */
+    constructor(injector, table, column) {
+        this.injector = injector;
+        this.table = table;
+        this.column = column;
+        this.field = this.column.name.replace('filter.', '');
+        if (!this.enum) {
+            this.http = injector.get(HttpClient);
+        }
+    }
+    /**
+     * Lifecycle hook that is called after data-bound properties of a directive are initialized.
+     */
+    ngOnInit() {
+        if (this.enum) {
+            this.filterable = this.enumMetadata != null;
+            this.options = this.enumMetadata ? EnumService.getOrderedValues(this.enum, this.enumMetadata) : EnumService.toArray(this.enum, this.prefix);
+            /* Apply enum filters */
+            if (this._enumFilter && this.options) {
+                this.options = this.options.filter(this._enumFilter);
+            }
+        }
+        else if (this.http && this.endpoint) {
+            this._endpointChange.subscribe(_ => {
+                let headers = new HttpHeaders();
+                if (this.cache) {
+                    headers.set('Client-Cache', 'Yes');
+                }
+                /* Init params, if null */
+                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 $event
+     */
+    handleFilter($event) {
+        let searchText = ($event?.target?.value ?? '').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; }
+    /**
+     * Called when the control receives a change event.
+     */
+    onChange = (_) => { };
+    /**
+     * Called when the control receives a touch event.
+     */
+    onTouched = () => { };
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: FilterSelectComponent, deps: [{ token: i0.Injector }, { token: i1.MatTable }, { token: i2.CdkColumnDef }], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.6", type: FilterSelectComponent, selector: "mat-header-cell[filter-select], [mat-header-cell][filter-select], [filter-select]", inputs: { endpoint: "endpoint", params: "params", projection: "projection", sortBy: "sortBy", sorted: "sorted", enumFilter: "enumFilter", enum: "enum", enumMetadata: "enumMetadata", key: "key", text: "text", prefix: "prefix", multiple: "multiple", options: "options", filteredOptions: "filteredOptions", filterable: "filterable", field: "field", placeholder: "placeholder", cache: "cache" }, host: { listeners: { "focusin": "onFocusIn()", "focusout": "onFocusOut()" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef((() => FilterSelectComponent)),
+                multi: true
+            },
+            {
+                provide: MAT_SELECT_CONFIG,
+                useValue: { overlayPanelClass: 'vd-select-filter-overlay' }
+            }
+        ], 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 [ngClass]=\"{'filter-not-empty': value}\" flex>\r\n    <span matPrefix *ngIf=\"!value && value!=0 && !focused\"><mat-icon fontSet=\"material-symbols-outlined\">manage_search</mat-icon></span>\r\n    <mat-select type=\"input\" [(ngModel)]=\"value\" [multiple]=\"multiple\" flex>\r\n        <mat-form-field *ngIf=\"filterable\" appearance=\"fill\" subscriptSizing=\"dynamic\" flex>\r\n            <input matInput #filterInput type=\"text\" placeholder=\"Filter...\" class=\"vd-select-filter\" (keyup)=\"handleFilter($event)\" flex>\r\n            <mat-icon *ngIf=\"filterInput?.value\" (click)=\"filterInput!.value = ''; handleFilter($event);\" fontSet=\"material-symbols-outlined\">close</mat-icon>\r\n        </mat-form-field>\r\n        <mat-option *ngIf=\"!multiple\" class=\"tc-grey-500\"></mat-option>\r\n        <ng-template let-option let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n            <mat-option [value]=\"option[key]\">\r\n                <span *ngIf=\"!optionTemplate?.templateRef\" i18n=\"@@selection\">{option.name, select, option {option} other {{{option[text]}}}}</span>\r\n                <ng-template *ngIf=\"optionTemplate?.templateRef\" [ngTemplateOutlet]=\"optionTemplate!.templateRef\" [ngTemplateOutletContext]=\"{ option: option }\"></ng-template>\r\n            </mat-option>\r\n        </ng-template>\r\n    </mat-select>\r\n</mat-form-field>", dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatPrefix, selector: "[matPrefix], [matIconPrefix], [matTextPrefix]", inputs: ["matTextPrefix"] }, { kind: "component", type: i6.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i7.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i9.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: FilterSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mat-header-cell[filter-select], [mat-header-cell][filter-select], [filter-select]', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => FilterSelectComponent)),
+                            multi: true
+                        },
+                        {
+                            provide: MAT_SELECT_CONFIG,
+                            useValue: { overlayPanelClass: 'vd-select-filter-overlay' }
+                        }
+                    ], template: "<mat-form-field [ngClass]=\"{'filter-not-empty': value}\" flex>\r\n    <span matPrefix *ngIf=\"!value && value!=0 && !focused\"><mat-icon fontSet=\"material-symbols-outlined\">manage_search</mat-icon></span>\r\n    <mat-select type=\"input\" [(ngModel)]=\"value\" [multiple]=\"multiple\" flex>\r\n        <mat-form-field *ngIf=\"filterable\" appearance=\"fill\" subscriptSizing=\"dynamic\" flex>\r\n            <input matInput #filterInput type=\"text\" placeholder=\"Filter...\" class=\"vd-select-filter\" (keyup)=\"handleFilter($event)\" flex>\r\n            <mat-icon *ngIf=\"filterInput?.value\" (click)=\"filterInput!.value = ''; handleFilter($event);\" fontSet=\"material-symbols-outlined\">close</mat-icon>\r\n        </mat-form-field>\r\n        <mat-option *ngIf=\"!multiple\" class=\"tc-grey-500\"></mat-option>\r\n        <ng-template let-option let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n            <mat-option [value]=\"option[key]\">\r\n                <span *ngIf=\"!optionTemplate?.templateRef\" i18n=\"@@selection\">{option.name, select, option {option} other {{{option[text]}}}}</span>\r\n                <ng-template *ngIf=\"optionTemplate?.templateRef\" [ngTemplateOutlet]=\"optionTemplate!.templateRef\" [ngTemplateOutletContext]=\"{ option: option }\"></ng-template>\r\n            </mat-option>\r\n        </ng-template>\r\n    </mat-select>\r\n</mat-form-field>" }]
+        }], ctorParameters: () => [{ 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
+            }], enumFilter: [{
+                type: Input
+            }], enum: [{
+                type: Input
+            }], enumMetadata: [{
+                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
+            }], onFocusIn: [{
+                type: HostListener,
+                args: ["focusin"]
+            }], onFocusOut: [{
+                type: HostListener,
+                args: ["focusout"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-select.component.js","sourceRoot":"","sources":["../../../../../../../projects/cdk/src/lib/table/components/filter-select/filter-select.component.ts","../../../../../../../projects/cdk/src/lib/table/components/filter-select/filter-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { CdkPortal } 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, HostListener, Injector, Input, OnInit, TemplateRef, ViewChild, ViewContainerRef, forwardRef } from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { MAT_SELECT_CONFIG, MatSelect } from '@angular/material/select';\r\nimport { MatTable } from '@angular/material/table';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { EnumMetadata } from '../../../common/models/enum-metadata';\r\nimport { EnumService } from '../../../common/services/enum.service';\r\n\r\n@Directive({ selector: '[vd-filter-option]ng-template' })\r\nexport class VdFilterOptionDirective extends CdkPortal {\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], [filter-select]',\r\n\ttemplateUrl: './filter-select.component.html',\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\t{\r\n\t\t\tprovide: MAT_SELECT_CONFIG,\r\n\t\t\tuseValue: { overlayPanelClass: 'vd-select-filter-overlay' }\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: BehaviorSubject<any[]> = new BehaviorSubject(<any>[]);\r\n\r\n\t/**\r\n\t * Represents a value that changes over time. \r\n\t */\r\n\tprivate _enumChange: BehaviorSubject<any[]> = new BehaviorSubject(<any>[]);\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(): string | undefined { 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 * _enumFilter: Function\r\n\t */\r\n\tprotected _enumFilter?: Function;\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 * @property\r\n\t */\r\n\t@Input()\r\n\tpublic get enumFilter(): Function | undefined { return this._enumFilter; }\r\n\tpublic set enumFilter(enumFilter: Function) { this._enumFilter = enumFilter; this._enumChange.next([this._enumFilter]); }\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 * Metadata for enum types.\r\n\t * @property\r\n\t */\r\n\t@Input()\r\n\tpublic enumMetadata?: { [key in any]: EnumMetadata };\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;\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 as any)['fieldFilters'][this.field]; };\r\n\tset value(v: any) {\r\n\t\tif (v != (this.table.dataSource as any)['fieldFilters'][this.field]) {\r\n\t\t\t(this.table.dataSource as any)['fieldFilters'][this.field] = v;\r\n\t\t\t(this.table.dataSource as any)['paginator']['pageIndex'] = 0;\r\n\t\t\t(this.table.dataSource as any)['reload']();\r\n\t\t\tthis.onChange(v);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Whether the control is focused.\r\n\t */\r\n\tpublic focused = false;\r\n\r\n\t/**\r\n\t * Whether the control is focused.\r\n\t */\r\n\t@HostListener(\"focusin\") onFocusIn() { this.focused = true; }\r\n\t@HostListener(\"focusout\") onFocusOut() { this.focused = false; }\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.filterable = this.enumMetadata != null;\r\n\t\t\tthis.options = this.enumMetadata ? EnumService.getOrderedValues(this.enum, this.enumMetadata) : EnumService.toArray(this.enum, this.prefix);\r\n\r\n\t\t\t/* Apply enum filters */\r\n\t\t\tif (this._enumFilter && this.options) {\r\n\t\t\t\tthis.options = this.options.filter(this._enumFilter);\r\n\t\t\t}\r\n\t\t} else if (this.http && this.endpoint) {\r\n\t\t\tthis._endpointChange.subscribe(_ => {\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 $event \r\n\t */\r\n\tpublic handleFilter($event: Event): void {\r\n\t\tlet searchText: string = (($event?.target as HTMLInputElement)?.value ?? '').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 = (_: any) => { };\r\n\r\n\t/**\r\n\t * Called when the control receives a touch event.\r\n\t */\r\n\tonTouched = () => { };\r\n}","<mat-form-field [ngClass]=\"{'filter-not-empty': value}\" flex>\r\n    <span matPrefix *ngIf=\"!value && value!=0 && !focused\"><mat-icon fontSet=\"material-symbols-outlined\">manage_search</mat-icon></span>\r\n    <mat-select type=\"input\" [(ngModel)]=\"value\" [multiple]=\"multiple\" flex>\r\n        <mat-form-field *ngIf=\"filterable\" appearance=\"fill\" subscriptSizing=\"dynamic\" flex>\r\n            <input matInput #filterInput type=\"text\" placeholder=\"Filter...\" class=\"vd-select-filter\" (keyup)=\"handleFilter($event)\" flex>\r\n            <mat-icon *ngIf=\"filterInput?.value\" (click)=\"filterInput!.value = ''; handleFilter($event);\" fontSet=\"material-symbols-outlined\">close</mat-icon>\r\n        </mat-form-field>\r\n        <mat-option *ngIf=\"!multiple\" class=\"tc-grey-500\"></mat-option>\r\n        <ng-template let-option let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n            <mat-option [value]=\"option[key]\">\r\n                <span *ngIf=\"!optionTemplate?.templateRef\" i18n=\"@@selection\">{option.name, select, option {option} other {{{option[text]}}}}</span>\r\n                <ng-template *ngIf=\"optionTemplate?.templateRef\" [ngTemplateOutlet]=\"optionTemplate!.templateRef\" [ngTemplateOutletContext]=\"{ option: option }\"></ng-template>\r\n            </mat-option>\r\n        </ng-template>\r\n    </mat-select>\r\n</mat-form-field>"]}

package/esm2022/lib/table/public_api.mjs

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

package/esm2022/lib/table/table.module.mjs

@@ -24,7 +24,7 @@ import { VdDynamicTableComponent } from './components/dynamic-table/dynamic-tabl
 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 { FilterSelectComponent, VdFilterOptionDirective } from './components/filter-select/filter-select.component';
 import { DataSourceFilterDirective } from './directives/data-source-filter.directive';
 import { VdTableFieldDirective } from './directives/vd-table-field.directive';
 import { PaginatorIntl } from './paginator-intl';
@@ -43,7 +43,7 @@ export { TableColumnConfig } from './models/table-column-config';
 export { TableDefinition } from './models/table-definition';
 export { TableDataSource } from './table.data-source';
 export { TableStaticDataSource } from './table.static-data-source';
-export { DataSourceFilterDirective, FilterClearComponent, FilterDateComponent, FilterInputComponent, VdDynamicTableComponent, VdTableFieldDirective };
+export { DataSourceFilterDirective, FilterClearComponent, FilterDateComponent, FilterInputComponent, FilterSelectComponent, VdDynamicTableComponent, VdFilterOptionDirective, VdTableFieldDirective };
 const DECLARATIONS = [
     FilterInputComponent,
     FilterSelectComponent,
@@ -154,4 +154,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.module.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/table/table.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkTableModule } from '@angular/cdk/table';\r\nimport { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } 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 { MatToolbarModule } from '@angular/material/toolbar';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { VdCommonModule } from '../common/common.module';\r\nimport { VdLayoutModule } from '../layout/layout.module';\r\nimport { VdSelectModule } from '../select/select.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 { VdTableFieldDirective } from './directives/vd-table-field.directive';\r\nimport { PaginatorIntl } from './paginator-intl';\r\n\r\nexport { tableColumnsMetadataKey, tableDefinitionMetadataKey } from './constants/constants';\r\nexport { FilterOperator } from './enums/filter-operator';\r\nexport { Grid } from './enums/grid';\r\nexport { TableColumnType } from './enums/table-column-type';\r\nexport { Column, ColumnObject, Table } from './functions/decorators';\r\nexport { getTableDefinition } from './functions/functions';\r\nexport { Facet } from './models/facet';\r\nexport { FacetValue } from './models/facet-value';\r\nexport { Pagination } from './models/pagination';\r\nexport { TableColumn } from './models/table-column';\r\nexport { TableColumnConfig } from './models/table-column-config';\r\nexport { TableDefinition } from './models/table-definition';\r\nexport { TableDataSource } from './table.data-source';\r\nexport { TableStaticDataSource } from './table.static-data-source';\r\n\r\nexport {\r\n\tDataSourceFilterDirective, FilterClearComponent,\r\n\tFilterDateComponent,\r\n\tFilterInputComponent, VdDynamicTableComponent,\r\n\tVdTableFieldDirective\r\n};\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\tVdTableFieldDirective\r\n];\r\n\r\n@NgModule({\r\n\timports: [\r\n\t\tCommonModule,\r\n\t\tVdLayoutModule,\r\n\t\tVdCommonModule,\r\n\t\tVdSelectModule,\r\n\t\tFormsModule,\r\n\t\tReactiveFormsModule,\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\tMatToolbarModule,\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 { }"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.module.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/table/table.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkTableModule } from '@angular/cdk/table';\r\nimport { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { FormsModule, ReactiveFormsModule } 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 { MatToolbarModule } from '@angular/material/toolbar';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { VdCommonModule } from '../common/common.module';\r\nimport { VdLayoutModule } from '../layout/layout.module';\r\nimport { VdSelectModule } from '../select/select.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/filter-select.component';\r\nimport { DataSourceFilterDirective } from './directives/data-source-filter.directive';\r\nimport { VdTableFieldDirective } from './directives/vd-table-field.directive';\r\nimport { PaginatorIntl } from './paginator-intl';\r\n\r\nexport { tableColumnsMetadataKey, tableDefinitionMetadataKey } from './constants/constants';\r\nexport { FilterOperator } from './enums/filter-operator';\r\nexport { Grid } from './enums/grid';\r\nexport { TableColumnType } from './enums/table-column-type';\r\nexport { Column, ColumnObject, Table } from './functions/decorators';\r\nexport { getTableDefinition } from './functions/functions';\r\nexport { Facet } from './models/facet';\r\nexport { FacetValue } from './models/facet-value';\r\nexport { Pagination } from './models/pagination';\r\nexport { TableColumn } from './models/table-column';\r\nexport { TableColumnConfig } from './models/table-column-config';\r\nexport { TableDefinition } from './models/table-definition';\r\nexport { TableDataSource } from './table.data-source';\r\nexport { TableStaticDataSource } from './table.static-data-source';\r\n\r\nexport {\r\n\tDataSourceFilterDirective, FilterClearComponent,\r\n\tFilterDateComponent, FilterInputComponent, FilterSelectComponent, VdDynamicTableComponent, VdFilterOptionDirective, VdTableFieldDirective\r\n};\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\tVdTableFieldDirective\r\n];\r\n\r\n@NgModule({\r\n\timports: [\r\n\t\tCommonModule,\r\n\t\tVdLayoutModule,\r\n\t\tVdCommonModule,\r\n\t\tVdSelectModule,\r\n\t\tFormsModule,\r\n\t\tReactiveFormsModule,\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\tMatToolbarModule,\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/fesm2022/messaia-cdk.mjs

@@ -68,7 +68,7 @@ import { trigger, state, style, AUTO_STYLE, transition, group, query, animateChi
 import * as i3$3 from '@angular/cdk/a11y';
 import * as i2$1 from '@angular/material/core';
 import { mixinErrorState, MAT_DATE_FORMATS, ErrorStateMatcher, MatNativeDateModule } from '@angular/material/core';
-import { CdkPortal, TemplatePortalDirective } from '@angular/cdk/portal';
+import { CdkPortal } from '@angular/cdk/portal';
 import { SelectionModel } from '@angular/cdk/collections';
 import { MatExpansionPanel } from '@angular/material/expansion';
 import * as i2$3 from '@angular/material/snack-bar';
@@ -13281,7 +13281,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
                 args: ['keydown', ['$event']]
             }] } });
 
-class VdFilterOptionDirective extends TemplatePortalDirective {
+class VdFilterOptionDirective extends CdkPortal {
     constructor(templateRef, viewContainerRef) {
         super(templateRef, viewContainerRef);
     }
@@ -13568,43 +13568,11 @@ class FilterSelectComponent {
                 provide: MAT_SELECT_CONFIG,
                 useValue: { overlayPanelClass: 'vd-select-filter-overlay' }
             }
-        ], 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 [ngClass]="{'filter-not-empty': value}" flex>
-			<span matPrefix *ngIf="!value && value!=0 && !focused"><mat-icon fontSet="material-symbols-outlined">manage_search</mat-icon></span>
-			<mat-select type="input" [(ngModel)]="value" [multiple]="multiple" flex>			
-				<mat-form-field *ngIf="filterable" appearance="fill" subscriptSizing="dynamic" flex>
-					<input matInput #filterInput type="text" placeholder="Filter..." class="vd-select-filter" (keyup)="handleFilter($event)" flex>					
-					<mat-icon *ngIf="filterInput?.value" (click)="filterInput!.value = ''; handleFilter($event);" fontSet="material-symbols-outlined">close</mat-icon>
-				</mat-form-field>							
-				<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: ["::ng-deep .vd-select-filter-overlay{min-width:150px}:is() ::ng-deep .mat-mdc-select-panel{padding-top:0!important}:is() .mat-mdc-form-field{position:sticky;top:0;z-index:100;width:100%}:is() .mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:0!important}:is() .mat-mdc-form-field mat-icon{cursor:pointer}mat-icon{opacity:.7}\n"], dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i6.MatPrefix, selector: "[matPrefix], [matIconPrefix], [matTextPrefix]", inputs: ["matTextPrefix"] }, { kind: "component", type: i5$3.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i2$1.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i8.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] });
+        ], 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 [ngClass]=\"{'filter-not-empty': value}\" flex>\r\n    <span matPrefix *ngIf=\"!value && value!=0 && !focused\"><mat-icon fontSet=\"material-symbols-outlined\">manage_search</mat-icon></span>\r\n    <mat-select type=\"input\" [(ngModel)]=\"value\" [multiple]=\"multiple\" flex>\r\n        <mat-form-field *ngIf=\"filterable\" appearance=\"fill\" subscriptSizing=\"dynamic\" flex>\r\n            <input matInput #filterInput type=\"text\" placeholder=\"Filter...\" class=\"vd-select-filter\" (keyup)=\"handleFilter($event)\" flex>\r\n            <mat-icon *ngIf=\"filterInput?.value\" (click)=\"filterInput!.value = ''; handleFilter($event);\" fontSet=\"material-symbols-outlined\">close</mat-icon>\r\n        </mat-form-field>\r\n        <mat-option *ngIf=\"!multiple\" class=\"tc-grey-500\"></mat-option>\r\n        <ng-template let-option let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n            <mat-option [value]=\"option[key]\">\r\n                <span *ngIf=\"!optionTemplate?.templateRef\" i18n=\"@@selection\">{option.name, select, option {option} other {{{option[text]}}}}</span>\r\n                <ng-template *ngIf=\"optionTemplate?.templateRef\" [ngTemplateOutlet]=\"optionTemplate!.templateRef\" [ngTemplateOutletContext]=\"{ option: option }\"></ng-template>\r\n            </mat-option>\r\n        </ng-template>\r\n    </mat-select>\r\n</mat-form-field>", dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i6.MatPrefix, selector: "[matPrefix], [matIconPrefix], [matTextPrefix]", inputs: ["matTextPrefix"] }, { kind: "component", type: i5$3.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i2$1.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i8.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: FilterSelectComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'mat-header-cell[filter-select], [mat-header-cell][filter-select], [filter-select]', template: `
-		<mat-form-field [ngClass]="{'filter-not-empty': value}" flex>
-			<span matPrefix *ngIf="!value && value!=0 && !focused"><mat-icon fontSet="material-symbols-outlined">manage_search</mat-icon></span>
-			<mat-select type="input" [(ngModel)]="value" [multiple]="multiple" flex>			
-				<mat-form-field *ngIf="filterable" appearance="fill" subscriptSizing="dynamic" flex>
-					<input matInput #filterInput type="text" placeholder="Filter..." class="vd-select-filter" (keyup)="handleFilter($event)" flex>					
-					<mat-icon *ngIf="filterInput?.value" (click)="filterInput!.value = ''; handleFilter($event);" fontSet="material-symbols-outlined">close</mat-icon>
-				</mat-form-field>							
-				<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>`, providers: [
+            args: [{ selector: 'mat-header-cell[filter-select], [mat-header-cell][filter-select], [filter-select]', providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
                             useExisting: forwardRef((() => FilterSelectComponent)),
@@ -13614,7 +13582,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
                             provide: MAT_SELECT_CONFIG,
                             useValue: { overlayPanelClass: 'vd-select-filter-overlay' }
                         }
-                    ], styles: ["::ng-deep .vd-select-filter-overlay{min-width:150px}:is() ::ng-deep .mat-mdc-select-panel{padding-top:0!important}:is() .mat-mdc-form-field{position:sticky;top:0;z-index:100;width:100%}:is() .mat-mdc-form-field.mat-focused .mat-mdc-form-field-focus-overlay{opacity:0!important}:is() .mat-mdc-form-field mat-icon{cursor:pointer}mat-icon{opacity:.7}\n"] }]
+                    ], template: "<mat-form-field [ngClass]=\"{'filter-not-empty': value}\" flex>\r\n    <span matPrefix *ngIf=\"!value && value!=0 && !focused\"><mat-icon fontSet=\"material-symbols-outlined\">manage_search</mat-icon></span>\r\n    <mat-select type=\"input\" [(ngModel)]=\"value\" [multiple]=\"multiple\" flex>\r\n        <mat-form-field *ngIf=\"filterable\" appearance=\"fill\" subscriptSizing=\"dynamic\" flex>\r\n            <input matInput #filterInput type=\"text\" placeholder=\"Filter...\" class=\"vd-select-filter\" (keyup)=\"handleFilter($event)\" flex>\r\n            <mat-icon *ngIf=\"filterInput?.value\" (click)=\"filterInput!.value = ''; handleFilter($event);\" fontSet=\"material-symbols-outlined\">close</mat-icon>\r\n        </mat-form-field>\r\n        <mat-option *ngIf=\"!multiple\" class=\"tc-grey-500\"></mat-option>\r\n        <ng-template let-option let-first=\"first\" ngFor [ngForOf]=\"filteredOptions\">\r\n            <mat-option [value]=\"option[key]\">\r\n                <span *ngIf=\"!optionTemplate?.templateRef\" i18n=\"@@selection\">{option.name, select, option {option} other {{{option[text]}}}}</span>\r\n                <ng-template *ngIf=\"optionTemplate?.templateRef\" [ngTemplateOutlet]=\"optionTemplate!.templateRef\" [ngTemplateOutletContext]=\"{ option: option }\"></ng-template>\r\n            </mat-option>\r\n        </ng-template>\r\n    </mat-select>\r\n</mat-form-field>" }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: i1$4.MatTable }, { type: i2$2.CdkColumnDef }], propDecorators: { optionTemplate: [{
                 type: ContentChild,
                 args: [VdFilterOptionDirective]