ecabs-components 1.0.23 → 1.0.24-alpha

package/README.md

@@ -25,3 +25,4 @@ To get more help on the Angular CLI use `ng help` or go check out the [Angular C
 
 v1.0.13 - Fixed emitEvent bahavior of checkbox
 v1.0.18 - - Fixed width of date time picker 
+v1.0.24-alpha - Added autocomplete component, skeletons and SEP date range picker. Removed legacy Material modules

package/esm2022/lib/base/directives/element-multiplier.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ElementMultiplierDirective {
+    templateRef;
+    viewContainer;
+    constructor(templateRef, viewContainer) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+    }
+    set appElementMultiplier(times) {
+        for (let i = 0; i < times; i++) {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementMultiplierDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ElementMultiplierDirective, selector: "[appElementMultiplier]", inputs: { appElementMultiplier: "appElementMultiplier" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementMultiplierDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appElementMultiplier]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { appElementMultiplier: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1tdWx0aXBsaWVyLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VjYWJzLWNvbXBvbmVudHMvc3JjL2xpYi9iYXNlL2RpcmVjdGl2ZXMvZWxlbWVudC1tdWx0aXBsaWVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBaUMsTUFBTSxlQUFlLENBQUM7O0FBS2hGLE1BQU0sT0FBTywwQkFBMEI7SUFDaEI7SUFBdUM7SUFBNUQsWUFBcUIsV0FBNkIsRUFBVSxhQUErQjtRQUF0RSxnQkFBVyxHQUFYLFdBQVcsQ0FBa0I7UUFBVSxrQkFBYSxHQUFiLGFBQWEsQ0FBa0I7SUFBSyxDQUFDO0lBRWpHLElBQWEsb0JBQW9CLENBQUUsS0FBYTtRQUM5QyxLQUFNLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsS0FBSyxFQUFFLENBQUMsRUFBRSxFQUFHO1lBQ2hDLElBQUksQ0FBQyxhQUFhLENBQUMsa0JBQWtCLENBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBRSxDQUFDO1NBQzNEO0lBQ0gsQ0FBQzt3R0FQVSwwQkFBMEI7NEZBQTFCLDBCQUEwQjs7NEZBQTFCLDBCQUEwQjtrQkFIdEMsU0FBUzttQkFBRTtvQkFDVixRQUFRLEVBQUUsd0JBQXdCO2lCQUNuQztpSUFJYyxvQkFBb0I7c0JBQWhDLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBUZW1wbGF0ZVJlZiwgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQERpcmVjdGl2ZSgge1xyXG4gIHNlbGVjdG9yOiAnW2FwcEVsZW1lbnRNdWx0aXBsaWVyXScsXHJcbn0gKVxyXG5leHBvcnQgY2xhc3MgRWxlbWVudE11bHRpcGxpZXJEaXJlY3RpdmUge1xyXG4gIGNvbnN0cnVjdG9yKCBwcml2YXRlIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxhbnk+LCBwcml2YXRlIHZpZXdDb250YWluZXI6IFZpZXdDb250YWluZXJSZWYgKSB7IH1cclxuXHJcbiAgQElucHV0KCkgc2V0IGFwcEVsZW1lbnRNdWx0aXBsaWVyKCB0aW1lczogbnVtYmVyICkge1xyXG4gICAgZm9yICggbGV0IGkgPSAwOyBpIDwgdGltZXM7IGkrKyApIHtcclxuICAgICAgdGhpcy52aWV3Q29udGFpbmVyLmNyZWF0ZUVtYmVkZGVkVmlldyggdGhpcy50ZW1wbGF0ZVJlZiApO1xyXG4gICAgfVxyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/base/directives/element-multiplier.directive.module.mjs

@@ -0,0 +1,22 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ElementMultiplierDirective } from './element-multiplier.directive';
+import * as i0 from "@angular/core";
+export class ElementMultiplierDirectiveModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementMultiplierDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: ElementMultiplierDirectiveModule, declarations: [ElementMultiplierDirective], imports: [CommonModule], exports: [ElementMultiplierDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementMultiplierDirectiveModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementMultiplierDirectiveModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        ElementMultiplierDirective,
+                    ],
+                    exports: [
+                        ElementMultiplierDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1tdWx0aXBsaWVyLmRpcmVjdGl2ZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY2Ficy1jb21wb25lbnRzL3NyYy9saWIvYmFzZS9kaXJlY3RpdmVzL2VsZW1lbnQtbXVsdGlwbGllci5kaXJlY3RpdmUubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDOztBQVc1RSxNQUFNLE9BQU8sZ0NBQWdDO3dHQUFoQyxnQ0FBZ0M7eUdBQWhDLGdDQUFnQyxpQkFOekMsMEJBQTBCLGFBRmpCLFlBQVksYUFLckIsMEJBQTBCO3lHQUdqQixnQ0FBZ0MsWUFSaEMsWUFBWTs7NEZBUVosZ0NBQWdDO2tCQVQ1QyxRQUFRO21CQUFFO29CQUNULE9BQU8sRUFBRSxDQUFFLFlBQVksQ0FBRTtvQkFDekIsWUFBWSxFQUFFO3dCQUNaLDBCQUEwQjtxQkFDM0I7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLDBCQUEwQjtxQkFDM0I7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBFbGVtZW50TXVsdGlwbGllckRpcmVjdGl2ZSB9IGZyb20gJy4vZWxlbWVudC1tdWx0aXBsaWVyLmRpcmVjdGl2ZSc7XHJcblxyXG5ATmdNb2R1bGUoIHtcclxuICBpbXBvcnRzOiBbIENvbW1vbk1vZHVsZSBdLFxyXG4gIGRlY2xhcmF0aW9uczogW1xyXG4gICAgRWxlbWVudE11bHRpcGxpZXJEaXJlY3RpdmUsXHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBFbGVtZW50TXVsdGlwbGllckRpcmVjdGl2ZSxcclxuICBdLFxyXG59IClcclxuZXhwb3J0IGNsYXNzIEVsZW1lbnRNdWx0aXBsaWVyRGlyZWN0aXZlTW9kdWxlIHsgfVxyXG4iXX0=

package/esm2022/lib/base/directives/style-paginator.directive.mjs

@@ -0,0 +1,263 @@
+import { Directive, Host, Input, Optional, Self, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/paginator";
+export class EcabsStylePaginatorDirective {
+    matPaginator;
+    viewContainerRef;
+    renderer;
+    pageGapTxt = '...';
+    rangeStart;
+    rangeEnd;
+    buttons = [];
+    currentPageObj = {
+        length: 0,
+        pageIndex: 0,
+        pageSize: 0,
+        previousPageIndex: 0,
+    };
+    totalPages = 2;
+    unsubscribe$ = new Subject();
+    isNarrowPaginator = false;
+    paginatedData;
+    set showTotalPages(value) {
+        this.totalPages = value % 2 === 0 ? value + 1 : value;
+    }
+    get increment() {
+        return this.totalPages % 2 === 0 ? this.totalPages / 2 : (this.totalPages - 1) / 2;
+    }
+    get numOfPages() {
+        return this.matPaginator.getNumberOfPages();
+    }
+    get lastPageIndex() {
+        return this.matPaginator.getNumberOfPages() - 1;
+    }
+    constructor(matPaginator, viewContainerRef, renderer) {
+        this.matPaginator = matPaginator;
+        this.viewContainerRef = viewContainerRef;
+        this.renderer = renderer;
+        // to rerender buttons on items per page change and first, last, next and prior buttons
+        this.matPaginator.page.pipe(takeUntil(this.unsubscribe$)).subscribe((e) => {
+            this.initPaginator(e);
+        });
+    }
+    ngOnChanges() {
+        this.initPaginator({
+            length: this.matPaginator.length,
+            pageIndex: this.matPaginator.pageIndex,
+            pageSize: this.matPaginator.pageSize,
+            previousPageIndex: 0,
+        });
+        this.initPageRange();
+    }
+    // Initialize default state after view init
+    ngAfterViewInit() {
+        this.initPaginator({
+            length: this.matPaginator.length,
+            pageIndex: this.matPaginator.pageIndex,
+            pageSize: this.matPaginator.pageSize,
+            previousPageIndex: 0,
+        });
+        this.rangeStart = 0;
+        this.rangeEnd = this.totalPages - 1;
+        this.buildPaginator();
+        this.initPageRange();
+    }
+    ngOnDestroy() {
+        this.unsubscribe$.next(null);
+        this.unsubscribe$.complete();
+    }
+    buildPaginator() {
+        const pageSizeContainer = this.viewContainerRef.element.nativeElement.querySelector('div.mat-mdc-paginator-page-size');
+        const dropdownUnderline = this.viewContainerRef.element.nativeElement.querySelector('div.mat-mdc-paginator-page-size .mat-mdc-form-field-underline');
+        if (dropdownUnderline) {
+            this.renderer.removeChild(pageSizeContainer, dropdownUnderline);
+        }
+    }
+    buildPageNumbers() {
+        const actionContainer = this.viewContainerRef.element.nativeElement.querySelector('div.mat-mdc-paginator-range-actions');
+        const nextPageNode = this.viewContainerRef.element.nativeElement.querySelector('button.mat-mdc-paginator-navigation-next');
+        const rangeLabelContainer = this.viewContainerRef.element.nativeElement.querySelector('div.mat-mdc-paginator-range-label');
+        if (rangeLabelContainer) {
+            this.renderer.removeChild(actionContainer, rangeLabelContainer);
+        }
+        // remove buttons before creating new ones
+        if (this.buttons.length > 0) {
+            this.buttons.forEach((button) => {
+                this.renderer.removeChild(actionContainer, button);
+            });
+            // Empty state array
+            this.buttons.length = 0;
+        }
+        const buttonsArrayContainer = this.viewContainerRef.element.nativeElement.childNodes[0].childNodes[0].childNodes[2];
+        // initialize next page and previous page buttons
+        if (this.buttons.length === 0 && buttonsArrayContainer) {
+            const buttonsArray = buttonsArrayContainer.childNodes;
+            setTimeout(() => {
+                // eslint-disable-next-line @typescript-eslint/prefer-for-of
+                for (let i = 0; i < buttonsArray.length; i++) {
+                    if (buttonsArray[i].nodeName === 'BUTTON') {
+                        if (buttonsArray[i].innerHTML.length > 100) {
+                            this.renderer.setAttribute(buttonsArray[i], 'tabindex', '-1');
+                            this.renderer.setStyle(buttonsArray[i], 'border', '1px solid #A6A6A6');
+                            this.renderer.setStyle(buttonsArray[i], 'box-sizing', 'border-box');
+                            this.renderer.setStyle(buttonsArray[i], 'border-radius', '4px');
+                            this.renderer.setStyle(buttonsArray[i], 'margin', '0 1rem');
+                            const svgArrow = buttonsArray[i].childNodes[0].childNodes[0];
+                            if (svgArrow) {
+                                this.renderer.setStyle(svgArrow, 'padding-left', '8px');
+                            }
+                        }
+                        else if (buttonsArray[i].disabled) {
+                            this.renderer.setStyle(buttonsArray[i], 'font-weight', '700');
+                        }
+                    }
+                }
+            });
+        }
+        for (let i = 0; i < this.numOfPages; i++) {
+            if (i >= this.rangeStart && i <= this.rangeEnd) {
+                this.renderer.insertBefore(actionContainer, this.createButton(i, this.matPaginator.pageIndex), nextPageNode);
+            }
+            if (i === this.rangeEnd && this.numOfPages - 1 !== this.rangeEnd) {
+                this.renderer.insertBefore(actionContainer, this.createButton(this.pageGapTxt, this.rangeEnd), nextPageNode);
+            }
+        }
+    }
+    createButton(i, pageIndex) {
+        const linkBtn = this.renderer.createElement('button');
+        this.renderer.addClass(linkBtn, 'mat-button');
+        this.renderer.setStyle(linkBtn, 'background-color', 'white');
+        this.renderer.setStyle(linkBtn, 'padding', '0 8px');
+        this.renderer.setAttribute(linkBtn, 'tabindex', '-1');
+        if (this.isNarrowPaginator) {
+            this.renderer.setStyle(linkBtn, 'min-width', '32px');
+            this.renderer.setStyle(linkBtn, 'max-width', '32px');
+        }
+        else {
+            this.renderer.setStyle(linkBtn, 'min-width', '48px');
+        }
+        const pagingTxt = isNaN(i) ? this.pageGapTxt : +(i + 1);
+        const text = this.renderer.createText(pagingTxt + '');
+        this.renderer.addClass(linkBtn, 'mat-custom-page');
+        switch (i) {
+            case pageIndex:
+                this.renderer.setAttribute(linkBtn, 'disabled', 'disabled');
+                break;
+            case this.pageGapTxt:
+                let newIndex = this.currentPageObj.pageIndex + this.totalPages;
+                if (newIndex >= this.numOfPages) {
+                    newIndex = this.lastPageIndex;
+                }
+                if (pageIndex !== this.lastPageIndex) {
+                    this.renderer.listen(linkBtn, 'click', () => {
+                        this.switchPage(newIndex);
+                    });
+                }
+                if (pageIndex === this.lastPageIndex) {
+                    this.renderer.setAttribute(linkBtn, 'disabled', 'disabled');
+                }
+                break;
+            default:
+                this.renderer.listen(linkBtn, 'click', () => {
+                    this.switchPage(i);
+                });
+                break;
+        }
+        this.renderer.appendChild(linkBtn, text);
+        // Add button to private array for state
+        this.buttons.push(linkBtn);
+        return linkBtn;
+    }
+    // calculates the button range based on class input parameters and based on
+    // current page index value. Used to render new buttons after event.
+    initPageRange() {
+        const middleIndex = (this.rangeStart + this.rangeEnd) / 2;
+        this.rangeStart = this.calcRangeStart(middleIndex);
+        this.rangeEnd = this.calcRangeEnd(middleIndex);
+        this.buildPageNumbers();
+    }
+    // Helper function To calculate start of button range
+    calcRangeStart(middleIndex) {
+        switch (true) {
+            case this.currentPageObj.pageIndex === 0 && this.rangeStart !== 0:
+                return 0;
+            case this.currentPageObj.pageIndex > this.rangeEnd:
+                return this.currentPageObj.pageIndex + this.increment > this.lastPageIndex
+                    ? this.lastPageIndex - this.increment * 2
+                    : this.currentPageObj.pageIndex - this.increment;
+            case this.currentPageObj.pageIndex > this.currentPageObj.previousPageIndex &&
+                this.currentPageObj.pageIndex > middleIndex &&
+                this.rangeEnd < this.lastPageIndex:
+                return this.rangeStart + 1;
+            case this.currentPageObj.pageIndex < this.currentPageObj.previousPageIndex &&
+                this.currentPageObj.pageIndex < middleIndex &&
+                this.rangeStart > 0:
+                return this.rangeStart - 1;
+            default:
+                return this.rangeStart;
+        }
+    }
+    // Helpter function to calculate end of button range
+    calcRangeEnd(middleIndex) {
+        switch (true) {
+            case this.currentPageObj.pageIndex === 0 && this.rangeEnd !== this.totalPages:
+                return this.totalPages - 1;
+            case this.currentPageObj.pageIndex > this.rangeEnd:
+                return this.currentPageObj.pageIndex + this.increment > this.lastPageIndex
+                    ? this.lastPageIndex
+                    : this.currentPageObj.pageIndex + 1;
+            case this.currentPageObj.pageIndex > this.currentPageObj.previousPageIndex &&
+                this.currentPageObj.pageIndex > middleIndex &&
+                this.rangeEnd < this.lastPageIndex:
+                return this.rangeEnd + 1;
+            case this.currentPageObj.pageIndex < this.currentPageObj.previousPageIndex &&
+                this.currentPageObj.pageIndex < middleIndex &&
+                this.rangeStart >= 0 &&
+                this.rangeEnd > this.totalPages - 1:
+                return this.rangeEnd - 1;
+            default:
+                return this.rangeEnd;
+        }
+    }
+    // Helper function to switch page on non first, last, next and previous buttons only.
+    switchPage(i) {
+        const previousPageIndex = this.matPaginator.pageIndex;
+        this.matPaginator.pageIndex = i;
+        // tslint:disable-next-line: no-string-literal
+        this.matPaginator['_emitPageEvent'](previousPageIndex);
+        this.initPageRange();
+    }
+    initPaginator(pageObject) {
+        if (this.currentPageObj.pageSize !== pageObject.pageSize && this.currentPageObj.pageIndex !== 0) {
+            pageObject.pageIndex = 0;
+            this.rangeStart = 0;
+            this.rangeEnd = this.totalPages - 1;
+        }
+        this.currentPageObj = pageObject;
+        this.buildPaginator();
+        this.initPageRange();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsStylePaginatorDirective, deps: [{ token: i1.MatPaginator, host: true, optional: true, self: true }, { token: i0.ViewContainerRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: EcabsStylePaginatorDirective, selector: "[ecabsStylePaginator]", inputs: { isNarrowPaginator: "isNarrowPaginator", paginatedData: "paginatedData", showTotalPages: "showTotalPages" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsStylePaginatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ecabsStylePaginator]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatPaginator, decorators: [{
+                    type: Host
+                }, {
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: i0.ViewContainerRef }, { type: i0.Renderer2 }]; }, propDecorators: { isNarrowPaginator: [{
+                type: Input
+            }], paginatedData: [{
+                type: Input
+            }], showTotalPages: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"style-paginator.directive.js","sourceRoot":"","sources":["../../../../../../projects/ecabs-components/src/lib/base/directives/style-paginator.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterViewInit,\r\n  Directive,\r\n  Host,\r\n  Input,\r\n  OnChanges,\r\n  OnDestroy,\r\n  Optional,\r\n  Renderer2,\r\n  Self,\r\n  ViewContainerRef,\r\n} from '@angular/core';\r\nimport { MatButton } from '@angular/material/button';\r\nimport { MatPaginator } from '@angular/material/paginator';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { PaginationResponseModel } from '../../models/pagination.models';\r\n\r\ninterface PageObject {\r\n  length: number;\r\n  pageIndex: number;\r\n  pageSize: number;\r\n  previousPageIndex: number;\r\n}\r\n\r\n@Directive( {\r\n  selector: '[ecabsStylePaginator]',\r\n} )\r\nexport class EcabsStylePaginatorDirective implements AfterViewInit, OnChanges, OnDestroy {\r\n  private pageGapTxt = '...';\r\n  private rangeStart: number;\r\n  private rangeEnd: number;\r\n  private buttons = [];\r\n  private currentPageObj: PageObject = {\r\n    length: 0,\r\n    pageIndex: 0,\r\n    pageSize: 0,\r\n    previousPageIndex: 0,\r\n  };\r\n  private totalPages = 2;\r\n\r\n  private readonly unsubscribe$ = new Subject<any>();\r\n\r\n  @Input() isNarrowPaginator = false;\r\n  @Input() paginatedData: PaginationResponseModel;\r\n\r\n  @Input()\r\n  set showTotalPages( value: number ) {\r\n    this.totalPages = value % 2 === 0 ? value + 1 : value;\r\n  }\r\n\r\n  get increment(): number {\r\n    return this.totalPages % 2 === 0 ? this.totalPages / 2 : ( this.totalPages - 1 ) / 2;\r\n  }\r\n\r\n  get numOfPages(): number {\r\n    return this.matPaginator.getNumberOfPages();\r\n  }\r\n\r\n  get lastPageIndex(): number {\r\n    return this.matPaginator.getNumberOfPages() - 1;\r\n  }\r\n\r\n  constructor(\r\n    @Host() @Self() @Optional() private readonly matPaginator: MatPaginator,\r\n    private viewContainerRef: ViewContainerRef,\r\n    private renderer: Renderer2\r\n  ) {\r\n    // to rerender buttons on items per page change and first, last, next and prior buttons\r\n    this.matPaginator.page.pipe( takeUntil( this.unsubscribe$ ) ).subscribe( ( e: PageObject ) => {\r\n      this.initPaginator( e );\r\n    } );\r\n  }\r\n\r\n  ngOnChanges(): void {\r\n    this.initPaginator( {\r\n      length: this.matPaginator.length,\r\n      pageIndex: this.matPaginator.pageIndex,\r\n      pageSize: this.matPaginator.pageSize,\r\n      previousPageIndex: 0,\r\n    } );\r\n    this.initPageRange();\r\n  }\r\n\r\n  // Initialize default state after view init\r\n  ngAfterViewInit(): void {\r\n    this.initPaginator( {\r\n      length: this.matPaginator.length,\r\n      pageIndex: this.matPaginator.pageIndex,\r\n      pageSize: this.matPaginator.pageSize,\r\n      previousPageIndex: 0,\r\n    } );\r\n    this.rangeStart = 0;\r\n    this.rangeEnd = this.totalPages - 1;\r\n    this.buildPaginator();\r\n    this.initPageRange();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.unsubscribe$.next( null );\r\n    this.unsubscribe$.complete();\r\n  }\r\n\r\n  private buildPaginator(): void {\r\n    const pageSizeContainer = this.viewContainerRef.element.nativeElement.querySelector(\r\n      'div.mat-mdc-paginator-page-size'\r\n    );\r\n\r\n    const dropdownUnderline = this.viewContainerRef.element.nativeElement.querySelector(\r\n      'div.mat-mdc-paginator-page-size .mat-mdc-form-field-underline'\r\n    );\r\n\r\n    if ( dropdownUnderline ) {\r\n      this.renderer.removeChild( pageSizeContainer, dropdownUnderline );\r\n    }\r\n  }\r\n\r\n  private buildPageNumbers(): void {\r\n    const actionContainer = this.viewContainerRef.element.nativeElement.querySelector(\r\n      'div.mat-mdc-paginator-range-actions'\r\n    );\r\n    const nextPageNode = this.viewContainerRef.element.nativeElement.querySelector(\r\n      'button.mat-mdc-paginator-navigation-next'\r\n    );\r\n\r\n    const rangeLabelContainer = this.viewContainerRef.element.nativeElement.querySelector(\r\n      'div.mat-mdc-paginator-range-label'\r\n    );\r\n\r\n    if ( rangeLabelContainer ) {\r\n      this.renderer.removeChild( actionContainer, rangeLabelContainer );\r\n    }\r\n\r\n    // remove buttons before creating new ones\r\n    if ( this.buttons.length > 0 ) {\r\n      this.buttons.forEach( ( button ) => {\r\n        this.renderer.removeChild( actionContainer, button );\r\n      } );\r\n      // Empty state array\r\n      this.buttons.length = 0;\r\n    }\r\n\r\n    const buttonsArrayContainer = this.viewContainerRef.element.nativeElement.childNodes[ 0 ].childNodes[ 0 ].childNodes[ 2 ];\r\n    // initialize next page and previous page buttons\r\n    if ( this.buttons.length === 0 && buttonsArrayContainer ) {\r\n      const buttonsArray = buttonsArrayContainer.childNodes;\r\n\r\n      setTimeout( () => {\r\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\r\n        for ( let i = 0; i < buttonsArray.length; i++ ) {\r\n          if ( buttonsArray[ i ].nodeName === 'BUTTON' ) {\r\n            if ( buttonsArray[ i ].innerHTML.length > 100 ) {\r\n              this.renderer.setAttribute( buttonsArray[ i ], 'tabindex', '-1' );\r\n              this.renderer.setStyle( buttonsArray[ i ], 'border', '1px solid #A6A6A6' );\r\n              this.renderer.setStyle( buttonsArray[ i ], 'box-sizing', 'border-box' );\r\n              this.renderer.setStyle( buttonsArray[ i ], 'border-radius', '4px' );\r\n              this.renderer.setStyle( buttonsArray[ i ], 'margin', '0 1rem' );\r\n\r\n              const svgArrow = buttonsArray[ i ].childNodes[ 0 ].childNodes[ 0 ];\r\n              if ( svgArrow ) {\r\n                this.renderer.setStyle( svgArrow, 'padding-left', '8px' );\r\n              }\r\n            } else if ( buttonsArray[ i ].disabled ) {\r\n              this.renderer.setStyle( buttonsArray[ i ], 'font-weight', '700' );\r\n            }\r\n          }\r\n        }\r\n      } );\r\n    }\r\n\r\n    for ( let i = 0; i < this.numOfPages; i++ ) {\r\n      if ( i >= this.rangeStart && i <= this.rangeEnd ) {\r\n        this.renderer.insertBefore( actionContainer, this.createButton( i, this.matPaginator.pageIndex ), nextPageNode );\r\n      }\r\n\r\n      if ( i === this.rangeEnd && this.numOfPages - 1 !== this.rangeEnd ) {\r\n        this.renderer.insertBefore( actionContainer, this.createButton( this.pageGapTxt, this.rangeEnd ), nextPageNode );\r\n      }\r\n    }\r\n  }\r\n\r\n  private createButton( i: any, pageIndex: number ): any {\r\n    const linkBtn: MatButton = this.renderer.createElement( 'button' );\r\n    this.renderer.addClass( linkBtn, 'mat-button' );\r\n    this.renderer.setStyle( linkBtn, 'background-color', 'white' );\r\n    this.renderer.setStyle( linkBtn, 'padding', '0 8px' );\r\n    this.renderer.setAttribute( linkBtn, 'tabindex', '-1' );\r\n\r\n    if ( this.isNarrowPaginator ) {\r\n      this.renderer.setStyle( linkBtn, 'min-width', '32px' );\r\n      this.renderer.setStyle( linkBtn, 'max-width', '32px' );\r\n    } else {\r\n      this.renderer.setStyle( linkBtn, 'min-width', '48px' );\r\n    }\r\n\r\n    const pagingTxt = isNaN( i ) ? this.pageGapTxt : +( i + 1 );\r\n    const text = this.renderer.createText( pagingTxt + '' );\r\n\r\n    this.renderer.addClass( linkBtn, 'mat-custom-page' );\r\n    switch ( i ) {\r\n      case pageIndex:\r\n        this.renderer.setAttribute( linkBtn, 'disabled', 'disabled' );\r\n        break;\r\n\r\n      case this.pageGapTxt:\r\n        let newIndex = this.currentPageObj.pageIndex + this.totalPages;\r\n\r\n        if ( newIndex >= this.numOfPages ) {\r\n          newIndex = this.lastPageIndex;\r\n        }\r\n\r\n        if ( pageIndex !== this.lastPageIndex ) {\r\n          this.renderer.listen( linkBtn, 'click', () => {\r\n            this.switchPage( newIndex );\r\n          } );\r\n        }\r\n\r\n        if ( pageIndex === this.lastPageIndex ) {\r\n          this.renderer.setAttribute( linkBtn, 'disabled', 'disabled' );\r\n        }\r\n        break;\r\n\r\n      default:\r\n        this.renderer.listen( linkBtn, 'click', () => {\r\n          this.switchPage( i );\r\n        } );\r\n        break;\r\n    }\r\n\r\n    this.renderer.appendChild( linkBtn, text );\r\n    // Add button to private array for state\r\n    this.buttons.push( linkBtn );\r\n\r\n    return linkBtn;\r\n  }\r\n\r\n  // calculates the button range based on class input parameters and based on\r\n  // current page index value. Used to render new buttons after event.\r\n  private initPageRange(): void {\r\n    const middleIndex = ( this.rangeStart + this.rangeEnd ) / 2;\r\n\r\n    this.rangeStart = this.calcRangeStart( middleIndex );\r\n    this.rangeEnd = this.calcRangeEnd( middleIndex );\r\n    this.buildPageNumbers();\r\n  }\r\n\r\n  // Helper function To calculate start of button range\r\n  private calcRangeStart( middleIndex: number ): number {\r\n    switch ( true ) {\r\n      case this.currentPageObj.pageIndex === 0 && this.rangeStart !== 0:\r\n        return 0;\r\n\r\n      case this.currentPageObj.pageIndex > this.rangeEnd:\r\n        return this.currentPageObj.pageIndex + this.increment > this.lastPageIndex\r\n          ? this.lastPageIndex - this.increment * 2\r\n          : this.currentPageObj.pageIndex - this.increment;\r\n\r\n      case this.currentPageObj.pageIndex > this.currentPageObj.previousPageIndex &&\r\n        this.currentPageObj.pageIndex > middleIndex &&\r\n        this.rangeEnd < this.lastPageIndex:\r\n        return this.rangeStart + 1;\r\n\r\n      case this.currentPageObj.pageIndex < this.currentPageObj.previousPageIndex &&\r\n        this.currentPageObj.pageIndex < middleIndex &&\r\n        this.rangeStart > 0:\r\n        return this.rangeStart - 1;\r\n\r\n      default:\r\n        return this.rangeStart;\r\n    }\r\n  }\r\n\r\n  // Helpter function to calculate end of button range\r\n  private calcRangeEnd( middleIndex: number ): number {\r\n    switch ( true ) {\r\n      case this.currentPageObj.pageIndex === 0 && this.rangeEnd !== this.totalPages:\r\n        return this.totalPages - 1;\r\n\r\n      case this.currentPageObj.pageIndex > this.rangeEnd:\r\n        return this.currentPageObj.pageIndex + this.increment > this.lastPageIndex\r\n          ? this.lastPageIndex\r\n          : this.currentPageObj.pageIndex + 1;\r\n\r\n      case this.currentPageObj.pageIndex > this.currentPageObj.previousPageIndex &&\r\n        this.currentPageObj.pageIndex > middleIndex &&\r\n        this.rangeEnd < this.lastPageIndex:\r\n        return this.rangeEnd + 1;\r\n\r\n      case this.currentPageObj.pageIndex < this.currentPageObj.previousPageIndex &&\r\n        this.currentPageObj.pageIndex < middleIndex &&\r\n        this.rangeStart >= 0 &&\r\n        this.rangeEnd > this.totalPages - 1:\r\n        return this.rangeEnd - 1;\r\n\r\n      default:\r\n        return this.rangeEnd;\r\n    }\r\n  }\r\n\r\n  // Helper function to switch page on non first, last, next and previous buttons only.\r\n  private switchPage( i: number ): void {\r\n    const previousPageIndex = this.matPaginator.pageIndex;\r\n    this.matPaginator.pageIndex = i;\r\n    // tslint:disable-next-line: no-string-literal\r\n    this.matPaginator[ '_emitPageEvent' ]( previousPageIndex );\r\n    this.initPageRange();\r\n  }\r\n\r\n  private initPaginator( pageObject: PageObject ): void {\r\n    if ( this.currentPageObj.pageSize !== pageObject.pageSize && this.currentPageObj.pageIndex !== 0 ) {\r\n      pageObject.pageIndex = 0;\r\n      this.rangeStart = 0;\r\n      this.rangeEnd = this.totalPages - 1;\r\n    }\r\n    this.currentPageObj = pageObject;\r\n\r\n    this.buildPaginator();\r\n    this.initPageRange();\r\n  }\r\n}\r\n"]}

package/esm2022/lib/base/directives/style-paginator.module.mjs

@@ -0,0 +1,19 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { EcabsStylePaginatorDirective } from './style-paginator.directive';
+import * as i0 from "@angular/core";
+const COMPONENTS = [EcabsStylePaginatorDirective];
+export class EcabsStylePaginatorDirectiveModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsStylePaginatorDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: EcabsStylePaginatorDirectiveModule, declarations: [EcabsStylePaginatorDirective], imports: [CommonModule], exports: [EcabsStylePaginatorDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsStylePaginatorDirectiveModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsStylePaginatorDirectiveModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [COMPONENTS],
+                    imports: [CommonModule],
+                    exports: [COMPONENTS],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGUtcGFnaW5hdG9yLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VjYWJzLWNvbXBvbmVudHMvc3JjL2xpYi9iYXNlL2RpcmVjdGl2ZXMvc3R5bGUtcGFnaW5hdG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7QUFFM0UsTUFBTSxVQUFVLEdBQUcsQ0FBRSw0QkFBNEIsQ0FBRSxDQUFDO0FBT3BELE1BQU0sT0FBTyxrQ0FBa0M7d0dBQWxDLGtDQUFrQzt5R0FBbEMsa0NBQWtDLGlCQVAxQiw0QkFBNEIsYUFJcEMsWUFBWSxhQUpKLDRCQUE0Qjt5R0FPcEMsa0NBQWtDLFlBSGxDLFlBQVk7OzRGQUdaLGtDQUFrQztrQkFMOUMsUUFBUTttQkFBRTtvQkFDVCxZQUFZLEVBQUUsQ0FBRSxVQUFVLENBQUU7b0JBQzVCLE9BQU8sRUFBRSxDQUFFLFlBQVksQ0FBRTtvQkFDekIsT0FBTyxFQUFFLENBQUUsVUFBVSxDQUFFO2lCQUN4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEVjYWJzU3R5bGVQYWdpbmF0b3JEaXJlY3RpdmUgfSBmcm9tICcuL3N0eWxlLXBhZ2luYXRvci5kaXJlY3RpdmUnO1xyXG5cclxuY29uc3QgQ09NUE9ORU5UUyA9IFsgRWNhYnNTdHlsZVBhZ2luYXRvckRpcmVjdGl2ZSBdO1xyXG5cclxuQE5nTW9kdWxlKCB7XHJcbiAgZGVjbGFyYXRpb25zOiBbIENPTVBPTkVOVFMgXSxcclxuICBpbXBvcnRzOiBbIENvbW1vbk1vZHVsZSBdLFxyXG4gIGV4cG9ydHM6IFsgQ09NUE9ORU5UUyBdLFxyXG59IClcclxuZXhwb3J0IGNsYXNzIEVjYWJzU3R5bGVQYWdpbmF0b3JEaXJlY3RpdmVNb2R1bGUgeyB9XHJcbiJdfQ==

package/esm2022/lib/base/element-wrapper/element-wrapper.component.mjs

@@ -4,7 +4,7 @@ import * as i1 from "@angular/common";
 import * as i2 from "../../ecabs-loading/spinner/spinner.component";
 import * as i3 from "../validation/validation.component";
 import * as i4 from "@angular/material/icon";
-import * as i5 from "@angular/material/legacy-tooltip";
+import * as i5 from "@angular/material/tooltip";
 import * as i6 from "../hint/hint.component";
 export class ElementWrapperComponent {
     data;
@@ -29,7 +29,7 @@ export class ElementWrapperComponent {
         this.decrease.emit();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementWrapperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ElementWrapperComponent, selector: "app-element-wrapper", inputs: { data: "data", showCloseIcon: "showCloseIcon", focusedFlag: "focusedFlag", showPassword: "showPassword", control: "control" }, outputs: { showHidePassword: "showHidePassword", clear: "clear", increase: "increase", decrease: "decrease" }, ngImport: i0, template: "<div\r\n  class=\"form-field\"\r\n  [ngClass]=\"{\r\n    'form-field--invalid':\r\n      data?.showValidation && (data?.control?.touched || data?.showValidationOnNotTouched) && data?.control?.invalid,\r\n    disabled: data?.disabled,\r\n    'form-field--required': data?.required && data?.showAsterisk\r\n  }\"\r\n>\r\n  <div>\r\n    <label class=\"form-field__label\" [attr.for]=\"data?.name\" *ngIf=\"data?.label\">\r\n      <span [innerHTML]=\"data?.label\"></span>\r\n      <mat-icon class=\"icon\" *ngIf=\"data?.tooltip\" [matTooltip]=\"data?.tooltip\">error_outline</mat-icon>\r\n    </label>\r\n  </div>\r\n\r\n  <ng-content></ng-content>\r\n\r\n  <ecabs-loading-spinner class=\"spinner\" size=\"tiny\" *ngIf=\"data.loading\"></ecabs-loading-spinner>\r\n\r\n  <app-hint [element]=\"data?.control\" [showHint]=\"data?.showHint\" [maxValue]=\"data?.maxLength\"></app-hint>\r\n\r\n  <app-validations-messages\r\n    *ngIf=\"data?.showValidation && !data?.hideValidationMessage\"\r\n    [element]=\"data?.control\"\r\n    [label]=\"data?.label ? data?.label : data?.placeholder ? data.placeholder : data?.validationLabel\"\r\n    [showValidationOnNotTouched]=\"data?.showValidationOnNotTouched\"\r\n  >\r\n  </app-validations-messages>\r\n</div>\r\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.EcabsSpinnerComponent, selector: "ecabs-loading-spinner", inputs: ["size"] }, { kind: "component", type: i3.ValidationComponent, selector: "app-validations-messages", inputs: ["element", "label", "showValidationOnNotTouched", "updatedErrors"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i5.MatLegacyTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "component", type: i6.HintComponent, selector: "app-hint", inputs: ["element", "maxValue", "showHint"] }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ElementWrapperComponent, selector: "app-element-wrapper", inputs: { data: "data", showCloseIcon: "showCloseIcon", focusedFlag: "focusedFlag", showPassword: "showPassword", control: "control" }, outputs: { showHidePassword: "showHidePassword", clear: "clear", increase: "increase", decrease: "decrease" }, ngImport: i0, template: "<div\r\n  class=\"form-field\"\r\n  [ngClass]=\"{\r\n    'form-field--invalid':\r\n      data?.showValidation && (data?.control?.touched || data?.showValidationOnNotTouched) && data?.control?.invalid,\r\n    disabled: data?.disabled,\r\n    'form-field--required': data?.required && data?.showAsterisk\r\n  }\"\r\n>\r\n  <div>\r\n    <label class=\"form-field__label\" [attr.for]=\"data?.name\" *ngIf=\"data?.label\">\r\n      <span [innerHTML]=\"data?.label\"></span>\r\n      <mat-icon class=\"icon\" *ngIf=\"data?.tooltip\" [matTooltip]=\"data?.tooltip\">error_outline</mat-icon>\r\n    </label>\r\n  </div>\r\n\r\n  <ng-content></ng-content>\r\n\r\n  <ecabs-loading-spinner class=\"spinner\" size=\"tiny\" *ngIf=\"data.loading\"></ecabs-loading-spinner>\r\n\r\n  <app-hint [element]=\"data?.control\" [showHint]=\"data?.showHint\" [maxValue]=\"data?.maxLength\"></app-hint>\r\n\r\n  <app-validations-messages\r\n    *ngIf=\"data?.showValidation && !data?.hideValidationMessage\"\r\n    [element]=\"data?.control\"\r\n    [label]=\"data?.label ? data?.label : data?.placeholder ? data.placeholder : data?.validationLabel\"\r\n    [showValidationOnNotTouched]=\"data?.showValidationOnNotTouched\"\r\n  >\r\n  </app-validations-messages>\r\n</div>\r\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.EcabsSpinnerComponent, selector: "ecabs-loading-spinner", inputs: ["size"] }, { kind: "component", type: i3.ValidationComponent, selector: "app-validations-messages", inputs: ["element", "label", "showValidationOnNotTouched", "updatedErrors"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "component", type: i6.HintComponent, selector: "app-hint", inputs: ["element", "maxValue", "showHint"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementWrapperComponent, decorators: [{
             type: Component,

package/esm2022/lib/base/element-wrapper/element-wrapper.module.mjs

@@ -6,9 +6,9 @@ import { ValidationModule } from '../validation/validation.module';
 import { ElementWrapperComponent } from './element-wrapper.component';
 import { MatIconModule } from '@angular/material/icon';
 import { EcabsLoadingModule } from '../../ecabs-loading/ecabs-loading.module';
-import { MatLegacyFormFieldModule as MatFormFieldModule } from '@angular/material/legacy-form-field';
-import { MatLegacyInputModule as MatInputModule } from '@angular/material/legacy-input';
-import { MatLegacyTooltipModule as MatTooltipModule } from "@angular/material/legacy-tooltip";
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatTooltipModule } from "@angular/material/tooltip";
 import * as i0 from "@angular/core";
 export class ElementWrapperModule {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ElementWrapperModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -49,4 +49,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     exports: [ElementWrapperComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC13cmFwcGVyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VjYWJzLWNvbXBvbmVudHMvc3JjL2xpYi9iYXNlL2VsZW1lbnQtd3JhcHBlci9lbGVtZW50LXdyYXBwZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUUzQyxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFDcEUsT0FBTyxFQUFDLGFBQWEsRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLDBDQUEwQyxDQUFDO0FBQzVFLE9BQU8sRUFBQyx3QkFBd0IsSUFBSSxrQkFBa0IsRUFBQyxNQUFNLHFDQUFxQyxDQUFDO0FBQ25HLE9BQU8sRUFBQyxvQkFBb0IsSUFBSSxjQUFjLEVBQUMsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN0RixPQUFPLEVBQUMsc0JBQXNCLElBQUksZ0JBQWdCLEVBQUMsTUFBTSxrQ0FBa0MsQ0FBQzs7QUFpQjVGLE1BQU0sT0FBTyxvQkFBb0I7d0dBQXBCLG9CQUFvQjt5R0FBcEIsb0JBQW9CLGlCQWRoQix1QkFBdUIsYUFFcEMsWUFBWTtZQUNaLFdBQVc7WUFDWCxrQkFBa0I7WUFDbEIsZ0JBQWdCO1lBQ2hCLGtCQUFrQjtZQUNsQixjQUFjO1lBQ2QsYUFBYTtZQUNiLGdCQUFnQjtZQUNoQixVQUFVLGFBRUYsdUJBQXVCO3lHQUV0QixvQkFBb0IsWUFaN0IsWUFBWTtZQUNaLFdBQVc7WUFDWCxrQkFBa0I7WUFDbEIsZ0JBQWdCO1lBQ2hCLGtCQUFrQjtZQUNsQixjQUFjO1lBQ2QsYUFBYTtZQUNiLGdCQUFnQjtZQUNoQixVQUFVOzs0RkFJRCxvQkFBb0I7a0JBZmhDLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsdUJBQXVCLENBQUM7b0JBQ3ZDLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLFdBQVc7d0JBQ1gsa0JBQWtCO3dCQUNsQixnQkFBZ0I7d0JBQ2hCLGtCQUFrQjt3QkFDbEIsY0FBYzt3QkFDZCxhQUFhO3dCQUNiLGdCQUFnQjt3QkFDaEIsVUFBVTtxQkFDWDtvQkFDRCxPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQztpQkFDbkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7Rm9ybXNNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcclxuXHJcbmltcG9ydCB7SGludE1vZHVsZX0gZnJvbSAnLi4vaGludC9oaW50Lm1vZHVsZSc7XHJcbmltcG9ydCB7VmFsaWRhdGlvbk1vZHVsZX0gZnJvbSAnLi4vdmFsaWRhdGlvbi92YWxpZGF0aW9uLm1vZHVsZSc7XHJcbmltcG9ydCB7RWxlbWVudFdyYXBwZXJDb21wb25lbnR9IGZyb20gJy4vZWxlbWVudC13cmFwcGVyLmNvbXBvbmVudCc7XHJcbmltcG9ydCB7TWF0SWNvbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XHJcbmltcG9ydCB7RWNhYnNMb2FkaW5nTW9kdWxlfSBmcm9tICcuLi8uLi9lY2Ficy1sb2FkaW5nL2VjYWJzLWxvYWRpbmcubW9kdWxlJztcclxuaW1wb3J0IHtNYXRMZWdhY3lGb3JtRmllbGRNb2R1bGUgYXMgTWF0Rm9ybUZpZWxkTW9kdWxlfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9sZWdhY3ktZm9ybS1maWVsZCc7XHJcbmltcG9ydCB7TWF0TGVnYWN5SW5wdXRNb2R1bGUgYXMgTWF0SW5wdXRNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2xlZ2FjeS1pbnB1dCc7XHJcbmltcG9ydCB7TWF0TGVnYWN5VG9vbHRpcE1vZHVsZSBhcyBNYXRUb29sdGlwTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvbWF0ZXJpYWwvbGVnYWN5LXRvb2x0aXBcIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgZGVjbGFyYXRpb25zOiBbRWxlbWVudFdyYXBwZXJDb21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtcclxuICAgIENvbW1vbk1vZHVsZSxcclxuICAgIEZvcm1zTW9kdWxlLFxyXG4gICAgRWNhYnNMb2FkaW5nTW9kdWxlLFxyXG4gICAgVmFsaWRhdGlvbk1vZHVsZSxcclxuICAgIE1hdEZvcm1GaWVsZE1vZHVsZSxcclxuICAgIE1hdElucHV0TW9kdWxlLFxyXG4gICAgTWF0SWNvbk1vZHVsZSxcclxuICAgIE1hdFRvb2x0aXBNb2R1bGUsXHJcbiAgICBIaW50TW9kdWxlLFxyXG4gIF0sXHJcbiAgZXhwb3J0czogW0VsZW1lbnRXcmFwcGVyQ29tcG9uZW50XSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEVsZW1lbnRXcmFwcGVyTW9kdWxlIHtcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/base/hint/hint.module.mjs

@@ -2,7 +2,7 @@ import { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
 import { FormsModule } from '@angular/forms';
 import { HintComponent } from './hint.component';
-import { MatLegacyFormFieldModule as MatFormFieldModule } from '@angular/material/legacy-form-field';
+import { MatFormFieldModule } from '@angular/material/form-field';
 import * as i0 from "@angular/core";
 export class HintModule {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HintModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     exports: [HintComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGludC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY2Ficy1jb21wb25lbnRzL3NyYy9saWIvYmFzZS9oaW50L2hpbnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUMzQyxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDL0MsT0FBTyxFQUFDLHdCQUF3QixJQUFJLGtCQUFrQixFQUFDLE1BQU0scUNBQXFDLENBQUM7O0FBT25HLE1BQU0sT0FBTyxVQUFVO3dHQUFWLFVBQVU7eUdBQVYsVUFBVSxpQkFKTixhQUFhLGFBQ2xCLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCLGFBQzdDLGFBQWE7eUdBRVosVUFBVSxZQUhYLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCOzs0RkFHNUMsVUFBVTtrQkFMdEIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxhQUFhLENBQUM7b0JBQzdCLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCLENBQUM7b0JBQ3hELE9BQU8sRUFBRSxDQUFDLGFBQWEsQ0FBQztpQkFDekIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7Rm9ybXNNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcclxuaW1wb3J0IHtIaW50Q29tcG9uZW50fSBmcm9tICcuL2hpbnQuY29tcG9uZW50JztcclxuaW1wb3J0IHtNYXRMZWdhY3lGb3JtRmllbGRNb2R1bGUgYXMgTWF0Rm9ybUZpZWxkTW9kdWxlfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9sZWdhY3ktZm9ybS1maWVsZCc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW0hpbnRDb21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBNYXRGb3JtRmllbGRNb2R1bGVdLFxyXG4gIGV4cG9ydHM6IFtIaW50Q29tcG9uZW50XSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEhpbnRNb2R1bGUge1xyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGludC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY2Ficy1jb21wb25lbnRzL3NyYy9saWIvYmFzZS9oaW50L2hpbnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sOEJBQThCLENBQUM7O0FBT2xFLE1BQU0sT0FBTyxVQUFVO3dHQUFWLFVBQVU7eUdBQVYsVUFBVSxpQkFKTCxhQUFhLGFBQ2xCLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCLGFBQzdDLGFBQWE7eUdBRWIsVUFBVSxZQUhWLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCOzs0RkFHN0MsVUFBVTtrQkFMdEIsUUFBUTttQkFBRTtvQkFDVCxZQUFZLEVBQUUsQ0FBRSxhQUFhLENBQUU7b0JBQy9CLE9BQU8sRUFBRSxDQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCLENBQUU7b0JBQzFELE9BQU8sRUFBRSxDQUFFLGFBQWEsQ0FBRTtpQkFDM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBGb3Jtc01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcclxuaW1wb3J0IHsgSGludENvbXBvbmVudCB9IGZyb20gJy4vaGludC5jb21wb25lbnQnO1xyXG5pbXBvcnQgeyBNYXRGb3JtRmllbGRNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9mb3JtLWZpZWxkJztcclxuXHJcbkBOZ01vZHVsZSgge1xyXG4gIGRlY2xhcmF0aW9uczogWyBIaW50Q29tcG9uZW50IF0sXHJcbiAgaW1wb3J0czogWyBDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBNYXRGb3JtRmllbGRNb2R1bGUgXSxcclxuICBleHBvcnRzOiBbIEhpbnRDb21wb25lbnQgXSxcclxufSApXHJcbmV4cG9ydCBjbGFzcyBIaW50TW9kdWxlIHtcclxufVxyXG4iXX0=

package/esm2022/lib/base/validation/validation.module.mjs

@@ -2,7 +2,7 @@ import { NgModule } from '@angular/core';
 import { ValidationComponent } from './validation.component';
 import { FormsModule } from '@angular/forms';
 import { CommonModule } from '@angular/common';
-import { MatLegacyFormFieldModule as MatFormFieldModule } from '@angular/material/legacy-form-field';
+import { MatFormFieldModule } from '@angular/material/form-field';
 import * as i0 from "@angular/core";
 export class ValidationModule {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ValidationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     exports: [ValidationComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY2Ficy1jb21wb25lbnRzL3NyYy9saWIvYmFzZS92YWxpZGF0aW9uL3ZhbGlkYXRpb24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFDM0QsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBQzNDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsd0JBQXdCLElBQUksa0JBQWtCLEVBQUMsTUFBTSxxQ0FBcUMsQ0FBQzs7QUFPbkcsTUFBTSxPQUFPLGdCQUFnQjt3R0FBaEIsZ0JBQWdCO3lHQUFoQixnQkFBZ0IsaUJBSlosbUJBQW1CLGFBQ3hCLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCLGFBQzdDLG1CQUFtQjt5R0FFbEIsZ0JBQWdCLFlBSGpCLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCOzs0RkFHNUMsZ0JBQWdCO2tCQUw1QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLG1CQUFtQixDQUFDO29CQUNuQyxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLGtCQUFrQixDQUFDO29CQUN4RCxPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztpQkFDL0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtWYWxpZGF0aW9uQ29tcG9uZW50fSBmcm9tICcuL3ZhbGlkYXRpb24uY29tcG9uZW50JztcclxuaW1wb3J0IHtGb3Jtc01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHtNYXRMZWdhY3lGb3JtRmllbGRNb2R1bGUgYXMgTWF0Rm9ybUZpZWxkTW9kdWxlfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9sZWdhY3ktZm9ybS1maWVsZCc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW1ZhbGlkYXRpb25Db21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBNYXRGb3JtRmllbGRNb2R1bGVdLFxyXG4gIGV4cG9ydHM6IFtWYWxpZGF0aW9uQ29tcG9uZW50XSxcclxufSlcclxuZXhwb3J0IGNsYXNzIFZhbGlkYXRpb25Nb2R1bGUge1xyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lY2Ficy1jb21wb25lbnRzL3NyYy9saWIvYmFzZS92YWxpZGF0aW9uL3ZhbGlkYXRpb24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDN0QsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQzs7QUFPbEUsTUFBTSxPQUFPLGdCQUFnQjt3R0FBaEIsZ0JBQWdCO3lHQUFoQixnQkFBZ0IsaUJBSlgsbUJBQW1CLGFBQ3hCLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCLGFBQzdDLG1CQUFtQjt5R0FFbkIsZ0JBQWdCLFlBSGhCLFlBQVksRUFBRSxXQUFXLEVBQUUsa0JBQWtCOzs0RkFHN0MsZ0JBQWdCO2tCQUw1QixRQUFRO21CQUFFO29CQUNULFlBQVksRUFBRSxDQUFFLG1CQUFtQixDQUFFO29CQUNyQyxPQUFPLEVBQUUsQ0FBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLGtCQUFrQixDQUFFO29CQUMxRCxPQUFPLEVBQUUsQ0FBRSxtQkFBbUIsQ0FBRTtpQkFDakMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBWYWxpZGF0aW9uQ29tcG9uZW50IH0gZnJvbSAnLi92YWxpZGF0aW9uLmNvbXBvbmVudCc7XHJcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBNYXRGb3JtRmllbGRNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9mb3JtLWZpZWxkJztcclxuXHJcbkBOZ01vZHVsZSgge1xyXG4gIGRlY2xhcmF0aW9uczogWyBWYWxpZGF0aW9uQ29tcG9uZW50IF0sXHJcbiAgaW1wb3J0czogWyBDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBNYXRGb3JtRmllbGRNb2R1bGUgXSxcclxuICBleHBvcnRzOiBbIFZhbGlkYXRpb25Db21wb25lbnQgXSxcclxufSApXHJcbmV4cG9ydCBjbGFzcyBWYWxpZGF0aW9uTW9kdWxlIHtcclxufVxyXG4iXX0=

package/esm2022/lib/ecabs-autocomplete/ecabs-autocomplete.component.mjs

@@ -0,0 +1,91 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { NgControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import ElementBaseComponent from '../base/element-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/material/autocomplete";
+import * as i3 from "@angular/material/core";
+import * as i4 from "../base/element-wrapper/element-wrapper.component";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/tooltip";
+export class EcabsAutocompleteComponent extends ElementBaseComponent {
+    injector;
+    digitsOnly;
+    allowDecimal;
+    allowHyphen;
+    suffixTooltip;
+    displayWith;
+    items;
+    onblur = new EventEmitter();
+    val;
+    get value() {
+        return this.val;
+    }
+    set value(val) {
+        if (val !== undefined && this.val !== val) {
+            this.val = val;
+            this.onChange(val);
+            if (this.getData()?.control?.updateOn !== 'blur') {
+                this.onTouch(val);
+            }
+        }
+    }
+    constructor(injector) {
+        super();
+        this.injector = injector;
+    }
+    ngAfterViewInit() {
+        const ngControl = this.injector.get(NgControl, null);
+        if (ngControl) {
+            this.control = ngControl.control;
+        }
+    }
+    onChange = () => { };
+    onTouch = () => { };
+    writeValue(value) {
+        this.value = value;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    blurChange(e) {
+        this.onTouch();
+        this.onblur.emit(e);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsAutocompleteComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: EcabsAutocompleteComponent, selector: "ecabs-autocomplete", inputs: { digitsOnly: "digitsOnly", allowDecimal: "allowDecimal", allowHyphen: "allowHyphen", suffixTooltip: "suffixTooltip", displayWith: "displayWith", items: "items" }, outputs: { onblur: "onblur" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: EcabsAutocompleteComponent,
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0, template: "<app-element-wrapper [data]=\"getData()\">\r\n  <div class=\"form-field__input--wrapper\">\r\n    <input\r\n      class=\"form-field__input\"\r\n      type=\"text\"\r\n      [id]=\"name\"\r\n      [(ngModel)]=\"value\"\r\n      [placeholder]=\"placeholder\"\r\n      [disabled]=\"disabled\"\r\n      [matAutocomplete]=\"autocompleteItems\"\r\n      (blur)=\"blurChange($event)\"\r\n    />\r\n\r\n    <div class=\"form-field__input--suffix\" [matTooltip]=\"suffixTooltip\">\r\n      <ng-content select=\"mat-icon\"></ng-content>\r\n      <ng-content select=\".suffix\"></ng-content>\r\n    </div>\r\n\r\n    <mat-autocomplete\r\n    #autocompleteItems=\"matAutocomplete\"\r\n    [displayWith]=\"displayWith\"\r\n    class=\"mat-autocomplete-extended\"\r\n  >\r\n    <mat-option *ngFor=\"let item of items\" [value]=\"item.value\">\r\n      {{ item.label }}\r\n    </mat-option>\r\n  </mat-autocomplete>\r\n  </div>\r\n</app-element-wrapper>\r\n", dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i2.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple", "hideSingleSelectionIndicator"], exportAs: ["matAutocomplete"] }, { kind: "component", type: i3.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "directive", type: i2.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { kind: "component", type: i4.ElementWrapperComponent, selector: "app-element-wrapper", inputs: ["data", "showCloseIcon", "focusedFlag", "showPassword", "control"], outputs: ["showHidePassword", "clear", "increase", "decrease"] }, { kind: "directive", type: i5.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i6.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EcabsAutocompleteComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ecabs-autocomplete', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: EcabsAutocompleteComponent,
+                            multi: true,
+                        },
+                    ], template: "<app-element-wrapper [data]=\"getData()\">\r\n  <div class=\"form-field__input--wrapper\">\r\n    <input\r\n      class=\"form-field__input\"\r\n      type=\"text\"\r\n      [id]=\"name\"\r\n      [(ngModel)]=\"value\"\r\n      [placeholder]=\"placeholder\"\r\n      [disabled]=\"disabled\"\r\n      [matAutocomplete]=\"autocompleteItems\"\r\n      (blur)=\"blurChange($event)\"\r\n    />\r\n\r\n    <div class=\"form-field__input--suffix\" [matTooltip]=\"suffixTooltip\">\r\n      <ng-content select=\"mat-icon\"></ng-content>\r\n      <ng-content select=\".suffix\"></ng-content>\r\n    </div>\r\n\r\n    <mat-autocomplete\r\n    #autocompleteItems=\"matAutocomplete\"\r\n    [displayWith]=\"displayWith\"\r\n    class=\"mat-autocomplete-extended\"\r\n  >\r\n    <mat-option *ngFor=\"let item of items\" [value]=\"item.value\">\r\n      {{ item.label }}\r\n    </mat-option>\r\n  </mat-autocomplete>\r\n  </div>\r\n</app-element-wrapper>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { digitsOnly: [{
+                type: Input
+            }], allowDecimal: [{
+                type: Input
+            }], allowHyphen: [{
+                type: Input
+            }], suffixTooltip: [{
+                type: Input
+            }], displayWith: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], onblur: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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