keevo-components 2.0.107 → 2.0.109

package/esm2022/lib/api/base-components/base-component-crud.mjs

@@ -0,0 +1,80 @@
+import { Component } from '@angular/core';
+import { FormService } from '../services/form.service';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dynamicdialog";
+import * as i2 from "../services/notification.service";
+export class BaseComponentCrud {
+    constructor(dialogService, notificationService) {
+        this.dialogService = dialogService;
+        this.notificationService = notificationService;
+        this.isReport = false;
+        this.itemsReport = [];
+    }
+    /**
+     * Fecha um relatório
+     */
+    closeReport() {
+        this.isReport = false;
+    }
+    /**
+     * Abre um form dialog
+     * @param componentType - Componente que será renderizado
+     * @param callBackFunction - Função de callback que deverá ser chamada após o fechamento do dialog
+     * @param paramsDialog - Parâmetros do dialog
+     */
+    openDialog(componentType, callBackFunction, paramsDialog) {
+        // FormService.openDialog(
+        //   this.dialogService,
+        //   componentType,
+        //   callBackFunction,
+        //   paramsDialog);
+        const dialogRef = FormService.openDialog(this.dialogService, componentType, callBackFunction, paramsDialog);
+        // Garante que o estado atual seja mantido no histórico
+        // window.history.pushState(null, '', window.location.href);
+        // Configura a ação para quando o botão de voltar do navegador é pressionado
+        window.onpopstate = function () {
+            // Verifica se o dialog está aberto antes de fechá-lo
+            if (dialogRef && dialogRef.close) {
+                // dialogRef.onClose.subscribe(callBackFunction());
+                dialogRef.close();
+            }
+        };
+    }
+    /**
+     * Imprime um relatório na tela
+     * @param obs - Observable com o carregamento do relatório
+     */
+    printReportFilter(obs) {
+        obs
+            //.pipe(loading())
+            .subscribe({
+            next: (res) => {
+                this.itemsReport = res;
+                this.isReport = true;
+            },
+            error: (e) => {
+                this.toastError(e);
+            },
+        });
+    }
+    /**
+     * Exibe um toast com um erro
+     * @param err - Erro
+     */
+    toastError(err) {
+        if (err) {
+            if (err.message) {
+                this.notificationService.toastError(err.message);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentCrud, deps: [{ token: i1.DialogService }, { token: i2.NotificationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentCrud, selector: "ng-component", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentCrud, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i1.DialogService }, { type: i2.NotificationService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/api/base-components/base-component-dropdown-external.mjs

@@ -0,0 +1,31 @@
+import { Component, Input, ViewChild } from "@angular/core";
+import { BaseComponentDropDown } from "./base-component-dropdown";
+import { KvDropdownComponent } from "../../components/kv-inputs/kv-dropdown/kv-dropdown.component";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/component.service";
+import * as i2 from "primeng/dynamicdialog";
+export class BaseComponentDropDownExternal extends BaseComponentDropDown {
+    constructor(componentService, dialogService) {
+        super(componentService, dialogService);
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.dropDownComponent) {
+            this.dropDownComponent.formControl = this.formControl;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentDropDownExternal, deps: [{ token: i1.ComponentService }, { token: i2.DialogService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentDropDownExternal, selector: "ng-component", inputs: { formGroup: "formGroup" }, viewQueries: [{ propertyName: "dropDownComponent", first: true, predicate: KvDropdownComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentDropDownExternal, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i1.ComponentService }, { type: i2.DialogService }], propDecorators: { formGroup: [{
+                type: Input
+            }], dropDownComponent: [{
+                type: ViewChild,
+                args: [KvDropdownComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb21wb25lbnQtZHJvcGRvd24tZXh0ZXJuYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9rZWV2by1jb21wb25lbnRzL3NyYy9saWIvYXBpL2Jhc2UtY29tcG9uZW50cy9iYXNlLWNvbXBvbmVudC1kcm9wZG93bi1leHRlcm5hbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWlCLFNBQVMsRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSTNFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDhEQUE4RCxDQUFDOzs7O0FBS25HLE1BQU0sT0FBZ0IsNkJBQThCLFNBQVEscUJBQXFCO0lBSzdFLFlBQ0ksZ0JBQWtDLEVBQ2xDLGFBQTRCO1FBQzVCLEtBQUssQ0FBQyxnQkFBZ0IsRUFBRSxhQUFhLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRVEsZUFBZTtRQUNwQixLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7UUFFeEIsSUFBSSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUN6QixJQUFJLENBQUMsaUJBQWlCLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUM7UUFDMUQsQ0FBQztJQUNMLENBQUM7OEdBakJpQiw2QkFBNkI7a0dBQTdCLDZCQUE2QiwySUFHcEMsbUJBQW1CLHVFQUxwQixFQUFFOzsyRkFFTSw2QkFBNkI7a0JBSGxELFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLEVBQUU7aUJBQ2Y7aUhBR1ksU0FBUztzQkFBakIsS0FBSztnQkFDMEIsaUJBQWlCO3NCQUFoRCxTQUFTO3VCQUFDLG1CQUFtQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFmdGVyVmlld0luaXQsIENvbXBvbmVudCwgSW5wdXQsIFZpZXdDaGlsZCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IENvbXBvbmVudFNlcnZpY2UgfSBmcm9tIFwiLi4vc2VydmljZXMvY29tcG9uZW50LnNlcnZpY2VcIjtcclxuaW1wb3J0IHsgRGlhbG9nU2VydmljZSB9IGZyb20gXCJwcmltZW5nL2R5bmFtaWNkaWFsb2dcIjtcclxuaW1wb3J0IHsgRm9ybUdyb3VwIH0gZnJvbSBcIkBhbmd1bGFyL2Zvcm1zXCI7XHJcbmltcG9ydCB7IEJhc2VDb21wb25lbnREcm9wRG93biB9IGZyb20gXCIuL2Jhc2UtY29tcG9uZW50LWRyb3Bkb3duXCI7XHJcbmltcG9ydCB7IEt2RHJvcGRvd25Db21wb25lbnQgfSBmcm9tIFwiLi4vLi4vY29tcG9uZW50cy9rdi1pbnB1dHMva3YtZHJvcGRvd24va3YtZHJvcGRvd24uY29tcG9uZW50XCI7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICAgIHRlbXBsYXRlOiAnJyxcclxufSlcclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEJhc2VDb21wb25lbnREcm9wRG93bkV4dGVybmFsIGV4dGVuZHMgQmFzZUNvbXBvbmVudERyb3BEb3duIGltcGxlbWVudHMgQWZ0ZXJWaWV3SW5pdCB7XHJcblxyXG4gICAgQElucHV0KCkgZm9ybUdyb3VwITogRm9ybUdyb3VwO1xyXG4gICAgQFZpZXdDaGlsZChLdkRyb3Bkb3duQ29tcG9uZW50KSBkcm9wRG93bkNvbXBvbmVudCE6IEt2RHJvcGRvd25Db21wb25lbnQ7XHJcblxyXG4gICAgY29uc3RydWN0b3IoXHJcbiAgICAgICAgY29tcG9uZW50U2VydmljZTogQ29tcG9uZW50U2VydmljZSxcclxuICAgICAgICBkaWFsb2dTZXJ2aWNlOiBEaWFsb2dTZXJ2aWNlKSB7XHJcbiAgICAgICAgc3VwZXIoY29tcG9uZW50U2VydmljZSwgZGlhbG9nU2VydmljZSk7XHJcbiAgICB9XHJcblxyXG4gICAgb3ZlcnJpZGUgbmdBZnRlclZpZXdJbml0KCk6IHZvaWQge1xyXG4gICAgICAgIHN1cGVyLm5nQWZ0ZXJWaWV3SW5pdCgpO1xyXG5cclxuICAgICAgICBpZiAodGhpcy5kcm9wRG93bkNvbXBvbmVudCkge1xyXG4gICAgICAgICAgICB0aGlzLmRyb3BEb3duQ29tcG9uZW50LmZvcm1Db250cm9sID0gdGhpcy5mb3JtQ29udHJvbDtcclxuICAgICAgICB9XHJcbiAgICB9XHJcbn0iXX0=

package/esm2022/lib/api/base-components/base-component-dropdown.mjs

@@ -0,0 +1,238 @@
+import { Component, EventEmitter, Input, Output, } from '@angular/core';
+import { debounceTime, finalize, of } from 'rxjs';
+import { BaseComponentInput } from './base-component-input';
+import { ObjectService } from '../services/object.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/component.service";
+import * as i2 from "primeng/dynamicdialog";
+export class BaseComponentDropDown extends BaseComponentInput {
+    constructor(componentService, dialogService) {
+        super(componentService);
+        this.dialogService = dialogService;
+        this.capitalize = false;
+        this.filter = true;
+        this.lazy = false;
+        this.loading = false;
+        this.showAddButton = false;
+        this.showClear = true;
+        this.onAddClick = new EventEmitter();
+        this.onClick = new EventEmitter();
+        this.onLoadCombo = new EventEmitter();
+        this.onSelectionChange = new EventEmitter();
+        this.onSelectionValue = new EventEmitter();
+        this.requestComplete = new EventEmitter();
+        this.onFilter = new EventEmitter();
+        this.prepositions = [
+            'de',
+            'da',
+            'do',
+            'em',
+            'no',
+            'na',
+            'para',
+            'por',
+            'com',
+            'a',
+            'o',
+            'e',
+        ];
+        this.loadingCombo = () => {
+            if (!this.lazy) {
+                return (src) => {
+                    this.loading = true;
+                    return src.pipe(finalize(() => {
+                        this.loading = false;
+                    }));
+                };
+            }
+        };
+        this.registerOnTouched(() => { });
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.setPlaceHolder('Selecione um valor');
+        if (!this.lazy)
+            this.carregarCombo();
+    }
+    addClick(event) {
+        this.onAddClick.emit(event);
+    }
+    carregarCombo(filtro) {
+        if (filtro) {
+            this.carregarComboObs(this.listarCombo(filtro));
+        }
+        else {
+            this.carregarComboObs(this.listar());
+        }
+    }
+    carregarComboObs(obs) {
+        if (obs) {
+            obs
+                .pipe(debounceTime(450), this.loadingCombo())
+                .subscribe({
+                next: (data) => {
+                    this.options = this.capitalizeOptions(data);
+                    this.filteredOptions = this.options;
+                    this.requestComplete.emit(true);
+                },
+                error: (error) => {
+                    console.log(error);
+                },
+            });
+        }
+    }
+    emptyMessage() {
+        return (this.lazy ? 'Digite para pesquisar' : 'Nenhum resultado encontrado');
+    }
+    filterOptions(field, value) {
+        if (this.options) {
+            let lista = ObjectService.filterObject(this.options, field, value);
+            if (lista?.length > 0) {
+                of(lista).subscribe((opts) => {
+                    this.filteredOptions = this.capitalizeOptions(opts);
+                });
+            }
+            else
+                this.filteredOptions = [];
+        }
+    }
+    listar() { }
+    listarCombo(value) { }
+    openDialog(componentType, width, height) {
+        const ref = this.dialogService.open(componentType, {
+            width: width || '70%',
+            height: height,
+            closable: false,
+            maximizable: true,
+            data: { popup: true },
+        });
+        ref.onClose.subscribe((id) => {
+            if (id) {
+                this.listar()
+                    .pipe(this.loadingCombo())
+                    .subscribe((data) => {
+                    this.options = this.capitalizeOptions(data);
+                    this.filteredOptions = this.options;
+                    if (id)
+                        this.formControl?.setValue(id);
+                });
+            }
+        });
+    }
+    onInputChange(event) {
+        this.onSelectionValue.emit(event);
+        //Em nossas implementações o metodo é chamado 2 vezes, em seua segunda chamada o event se torna o objeto selecionado e não o valor, dessa forma o if abaixo apenas emite o objeto
+        if (!event?.originalEvent) {
+            this.onSelectionChange.emit(event);
+            return;
+        }
+        if (this.formControl) {
+            const controlName = this.getName(this.formControl);
+            if (controlName) {
+                let currentItem = ObjectService.findObject(this.options, this.optionValue ?? controlName, event?.value);
+                this.onSelectionChange.emit(currentItem);
+            }
+        }
+    }
+    onInputClick(event) {
+        this.onClick.emit(event);
+    }
+    onInputFilter(event) {
+        if (event) {
+            this.onFilter.emit(event.filter);
+            if (event.filter) {
+                if (event.filter.length > 2) {
+                    let fil = { termoPesquisa: event.filter };
+                    this.carregarCombo(fil);
+                    this.onLoadCombo.emit(fil);
+                }
+            }
+        }
+    }
+    writeValue(value) {
+        if (this.lazy && value) {
+            let fil = { id: value };
+            this.carregarCombo(fil);
+            this.onLoadCombo.emit(fil);
+        }
+        this.value = value;
+    }
+    transformCapitalize(value) {
+        if (!value)
+            return value;
+        return value
+            .split(' ')
+            .map((word, index) => {
+            if (index !== 0 &&
+                this.prepositions.includes(word.toLocaleLowerCase())) {
+                return word.toLocaleLowerCase();
+            }
+            return (word.charAt(0).toLocaleUpperCase() + word.slice(1).toLocaleLowerCase());
+        })
+            .join(' ');
+    }
+    capitalizeOptions(options) {
+        if (this.capitalize) {
+            return options?.map((option) => {
+                option[this.optionLabel] = this.transformCapitalize(option[this.optionLabel]);
+                return option;
+            });
+        }
+        return options;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentDropDown, deps: [{ token: i1.ComponentService }, { token: i2.DialogService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentDropDown, selector: "ng-component", inputs: { filteredOptions: "filteredOptions", options: "options", optionLabel: "optionLabel", optionValue: "optionValue", nameForSelectionChange: "nameForSelectionChange", optionDisabled: "optionDisabled", capitalize: "capitalize", group: "group", optionGroupLabel: "optionGroupLabel", optionGroupChildren: "optionGroupChildren", filter: "filter", lazy: "lazy", loading: "loading", showAddButton: "showAddButton", showClear: "showClear", widthField: "widthField" }, outputs: { onAddClick: "onAddClick", onClick: "onClick", onLoadCombo: "onLoadCombo", onSelectionChange: "onSelectionChange", onSelectionValue: "onSelectionValue", requestComplete: "requestComplete", onFilter: "onFilter" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentDropDown, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i1.ComponentService }, { type: i2.DialogService }], propDecorators: { filteredOptions: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], optionLabel: [{
+                type: Input
+            }], optionValue: [{
+                type: Input
+            }], nameForSelectionChange: [{
+                type: Input
+            }], optionDisabled: [{
+                type: Input
+            }], capitalize: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], optionGroupLabel: [{
+                type: Input
+            }], optionGroupChildren: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], lazy: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], showAddButton: [{
+                type: Input
+            }], showClear: [{
+                type: Input
+            }], widthField: [{
+                type: Input
+            }], onAddClick: [{
+                type: Output
+            }], onClick: [{
+                type: Output
+            }], onLoadCombo: [{
+                type: Output
+            }], onSelectionChange: [{
+                type: Output
+            }], onSelectionValue: [{
+                type: Output
+            }], requestComplete: [{
+                type: Output
+            }], onFilter: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-component-dropdown.js","sourceRoot":"","sources":["../../../../../../projects/keevo-components/src/lib/api/base-components/base-component-dropdown.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  Type,\r\n} from '@angular/core';\r\n\r\nimport { FormControl } from '@angular/forms';\r\nimport { Observable, debounceTime, finalize, of } from 'rxjs';\r\nimport { DialogService } from 'primeng/dynamicdialog';\r\nimport { BaseComponentInput } from './base-component-input';\r\nimport { ComponentService } from '../services/component.service';\r\nimport { ObjectService } from '../services/object.service';\r\nimport { filtroCombo } from '../components/dropdown/filtro.combo';\r\n\r\n@Component({\r\n  template: '',\r\n})\r\nexport abstract class BaseComponentDropDown extends BaseComponentInput<any> implements OnInit {\r\n\r\n  @Input() filteredOptions!: any[];\r\n  @Input() options!: any[];\r\n  @Input() optionLabel!: string;\r\n  @Input() optionValue!: string;\r\n\r\n  /**\r\n   * String que será utilizada para buscar a opção no método onSelectionChange\r\n   * @input\r\n   */\r\n  @Input() nameForSelectionChange!: string;\r\n  @Input() optionDisabled!: string;\r\n\r\n  @Input() capitalize: boolean = false;\r\n\r\n  @Input() group!: boolean;\r\n  @Input() optionGroupLabel!: string;\r\n  @Input() optionGroupChildren!: string;\r\n\r\n  @Input() filter: boolean = true;\r\n  @Input() lazy: boolean = false;\r\n  @Input() loading: boolean = false;\r\n\r\n  @Input() showAddButton: boolean = false;\r\n  @Input() showClear: boolean = true;\r\n  @Input() widthField?: string;\r\n\r\n  @Output() onAddClick: EventEmitter<any> = new EventEmitter();\r\n  @Output() onClick: EventEmitter<any> = new EventEmitter();\r\n  @Output() onLoadCombo: EventEmitter<any> = new EventEmitter();\r\n  @Output() onSelectionChange: EventEmitter<any> = new EventEmitter();\r\n  @Output() onSelectionValue: EventEmitter<any> = new EventEmitter();\r\n  @Output() requestComplete: EventEmitter<any> = new EventEmitter();\r\n  @Output() onFilter: EventEmitter<any> = new EventEmitter();\r\n\r\n  prepositions: string[] = [\r\n    'de',\r\n    'da',\r\n    'do',\r\n    'em',\r\n    'no',\r\n    'na',\r\n    'para',\r\n    'por',\r\n    'com',\r\n    'a',\r\n    'o',\r\n    'e',\r\n  ];\r\n\r\n  constructor(\r\n    componentService: ComponentService,\r\n    private dialogService: DialogService\r\n  ) {\r\n    super(componentService);\r\n    this.registerOnTouched(() => { });\r\n  }\r\n\r\n  override ngOnInit(): void {\r\n    super.ngOnInit();\r\n    this.setPlaceHolder('Selecione um valor');\r\n\r\n    if (!this.lazy) this.carregarCombo();\r\n  }\r\n\r\n  protected addClick(event: Event) {\r\n    this.onAddClick.emit(event);\r\n  }\r\n\r\n  public carregarCombo(filtro?: filtroCombo): void {\r\n\r\n    if (filtro) {\r\n      this.carregarComboObs(this.listarCombo(filtro));\r\n    }\r\n    else {\r\n      this.carregarComboObs(this.listar());\r\n    }\r\n  }\r\n\r\n  protected carregarComboObs(obs: Observable<any>) {\r\n    if (obs) {\r\n      obs\r\n        .pipe\r\n        (\r\n          debounceTime(450),\r\n          this.loadingCombo()\r\n        )\r\n        .subscribe({\r\n          next: (data: any) => {\r\n            this.options = this.capitalizeOptions(data);\r\n            this.filteredOptions = this.options;\r\n            this.requestComplete.emit(true);\r\n          },\r\n          error: (error: any) => {\r\n            console.log(error);\r\n          },\r\n        });\r\n    }\r\n  }\r\n\r\n  public emptyMessage() {\r\n    return (this.lazy ? 'Digite para pesquisar' : 'Nenhum resultado encontrado');\r\n  }\r\n\r\n  public filterOptions(field: string, value: any): void {\r\n    if (this.options) {\r\n      let lista = ObjectService.filterObject(this.options, field, value);\r\n      if (lista?.length > 0) {\r\n        of(lista).subscribe((opts: any[]) => {\r\n          this.filteredOptions = this.capitalizeOptions(opts);\r\n        });\r\n      } else this.filteredOptions = [];\r\n    }\r\n  }\r\n\r\n  protected listar(): any { }\r\n  protected listarCombo(value: any): any { }\r\n\r\n  loadingCombo = (): any => {\r\n    if (!this.lazy) {\r\n      return (src: Observable<any>) => {\r\n        this.loading = true;\r\n        return src.pipe(finalize(() => {\r\n          this.loading = false;\r\n        }));\r\n      };\r\n    }\r\n  };\r\n\r\n  protected openDialog(\r\n    componentType: Type<any>,\r\n    width?: string,\r\n    height?: string\r\n  ) {\r\n    const ref = this.dialogService.open(componentType, {\r\n      width: width || '70%',\r\n      height: height,\r\n      closable: false,\r\n      maximizable: true,\r\n      data: { popup: true },\r\n    });\r\n\r\n    ref.onClose.subscribe((id: any) => {\r\n      if (id) {\r\n        this.listar()\r\n          .pipe(this.loadingCombo())\r\n          .subscribe((data: any) => {\r\n            this.options = this.capitalizeOptions(data);\r\n            this.filteredOptions = this.options;\r\n            if (id) this.formControl?.setValue(id);\r\n          });\r\n      }\r\n    });\r\n  }\r\n\r\n  protected onInputChange(event: any) {\r\n    this.onSelectionValue.emit(event);\r\n    //Em nossas implementações o metodo é chamado 2 vezes, em seua segunda chamada o event se torna o objeto selecionado e não o valor, dessa forma o if abaixo apenas emite o objeto\r\n    if(!event?.originalEvent){\r\n      this.onSelectionChange.emit(event);\r\n      return;\r\n    }\r\n\r\n    if (this.formControl) {\r\n      const controlName = this.getName(this.formControl as FormControl);\r\n      if (controlName) {\r\n        let currentItem = ObjectService.findObject(\r\n          this.options,\r\n          this.optionValue??controlName,\r\n          event?.value\r\n        );\r\n        this.onSelectionChange.emit(currentItem);\r\n      }\r\n    }\r\n  }\r\n\r\n  onInputClick(event: any) {\r\n    this.onClick.emit(event);\r\n  }\r\n\r\n  onInputFilter(event: any) {\r\n    if (event) {\r\n      this.onFilter.emit(event.filter)\r\n\r\n      if (event.filter) {\r\n        if (event.filter.length > 2) {\r\n          let fil = { termoPesquisa: event.filter } as filtroCombo;\r\n          this.carregarCombo(fil);\r\n          this.onLoadCombo.emit(fil);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  override writeValue(value: any): void {\r\n    if (this.lazy && value) {\r\n      let fil = { id: value } as filtroCombo;\r\n      this.carregarCombo(fil);\r\n      this.onLoadCombo.emit(fil);\r\n    }\r\n    this.value = value;\r\n  }\r\n\r\n\r\n  transformCapitalize(value: string): string {\r\n\r\n    if (!value) return value;\r\n\r\n    return value\r\n      .split(' ')\r\n      .map((word, index) => {\r\n        if (\r\n          index !== 0 &&\r\n          this.prepositions.includes(word.toLocaleLowerCase())\r\n        ) {\r\n          return word.toLocaleLowerCase();\r\n        }\r\n        return (\r\n          word.charAt(0).toLocaleUpperCase() + word.slice(1).toLocaleLowerCase()\r\n        );\r\n      })\r\n      .join(' ');\r\n  }\r\n\r\n  capitalizeOptions(options: any[]): any[] {\r\n\r\n    if (this.capitalize) {\r\n      return options?.map((option: any) => {\r\n        option[this.optionLabel] = this.transformCapitalize(option[this.optionLabel]);\r\n\r\n        return option;\r\n      });\r\n    }\r\n    return options;\r\n  }\r\n}"]}

package/esm2022/lib/api/base-components/base-component-input.mjs

@@ -0,0 +1,101 @@
+import { Component, ContentChildren, EventEmitter, Input, Output, ViewChildren, } from '@angular/core';
+import { BaseComponent } from './base-component';
+import { KvErrorComponent } from '../../components/kv-error/kv-error.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/component.service";
+export class BaseComponentInput extends BaseComponent {
+    constructor(componentService) {
+        super();
+        this.componentService = componentService;
+        this.hasError = false;
+        this.showAsterisk = false;
+        this.placeholder = '';
+        this.autocomplete = '';
+        this.onBlur = new EventEmitter();
+        this.onInput = new EventEmitter();
+        this.onClose = new EventEmitter();
+    }
+    get baseInputClass() {
+        return `${this.hasError ? 'ng-invalid ng-dirty' : ''} !important`;
+    }
+    erroMessage() {
+        if (!this.formControl?.errors)
+            return;
+        let message = '';
+        if (this.formControl.errors) {
+            const objErrors = this.formControl.errors;
+            if (objErrors.erroMessage)
+                message = objErrors.erroMessage;
+        }
+        return message;
+    }
+    getName(control) {
+        return (Object.entries(control.parent?.controls ?? []).find(([_, value]) => value === control)?.[0] ?? null);
+    }
+    hasControlError() {
+        if (!this.formControl)
+            return false;
+        return ((this.formControl.dirty || this.formControl.touched) &&
+            this.formControl.errors !== null);
+    }
+    ngAfterViewInit() {
+        this.viewErrors.forEach((c) => {
+            c.emitError.subscribe((res) => {
+                this.hasError = res;
+                this.componentService.changeDetectorRef.detectChanges();
+            });
+        });
+    }
+    ngAfterContentInit() {
+        this.contentErrors.forEach((c) => {
+            c.emitError.subscribe((res) => {
+                this.hasError = res;
+            });
+        });
+    }
+    ngOnInit() {
+        this.formControl = this.componentService.getFormControl();
+        if (this.formControl?.errors?.['required'])
+            this.showAsterisk = true;
+    }
+    onInputBlur(event) {
+        if (this.onTouched)
+            this.onTouched();
+        this.onBlur.emit(event);
+    }
+    onInputClose(event) {
+        this.onClose.emit(event);
+    }
+    onInputInput(event) {
+        this.onInput.emit(event);
+    }
+    setPlaceHolder(p) {
+        if (!this.placeholder)
+            this.placeholder = p;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentInput, deps: [{ token: i1.ComponentService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentInput, selector: "ng-component", inputs: { placeholder: "placeholder", autocomplete: "autocomplete" }, outputs: { onBlur: "onBlur", onInput: "onInput", onClose: "onClose" }, queries: [{ propertyName: "contentErrors", predicate: KvErrorComponent }], viewQueries: [{ propertyName: "viewErrors", predicate: KvErrorComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentInput, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i1.ComponentService }], propDecorators: { placeholder: [{
+                type: Input
+            }], autocomplete: [{
+                type: Input
+            }], onBlur: [{
+                type: Output
+            }], onInput: [{
+                type: Output
+            }], onClose: [{
+                type: Output
+            }], viewErrors: [{
+                type: ViewChildren,
+                args: [KvErrorComponent]
+            }], contentErrors: [{
+                type: ContentChildren,
+                args: [KvErrorComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-component-input.js","sourceRoot":"","sources":["../../../../../../projects/keevo-components/src/lib/api/base-components/base-component-input.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  AfterContentInit,\r\n  AfterViewInit,\r\n  Component,\r\n  ContentChildren,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  QueryList,\r\n  ViewChildren,\r\n} from '@angular/core';\r\n\r\nimport { FormControl } from '@angular/forms';\r\n\r\nimport { BaseComponent } from './base-component';\r\n\r\nimport { ComponentService } from '../services/component.service';\r\nimport { KvErrorComponent } from '../../components/kv-error/kv-error.component';\r\n\r\n@Component({\r\n  template: '',\r\n})\r\nexport abstract class BaseComponentInput<T>\r\n  extends BaseComponent<T>\r\n  implements OnInit, AfterContentInit, AfterViewInit\r\n{\r\n  public formControl: FormControl | undefined;\r\n  protected hasError: boolean | undefined = false;\r\n  public showAsterisk = false;\r\n\r\n  @Input() placeholder: string = '';\r\n  @Input() autocomplete: string = '';\r\n  \r\n\r\n  @Output() onBlur: EventEmitter<any> = new EventEmitter();\r\n  @Output() onInput: EventEmitter<any> = new EventEmitter();\r\n  @Output() onClose: EventEmitter<any> = new EventEmitter();\r\n\r\n  @ViewChildren(KvErrorComponent) viewErrors!: QueryList<KvErrorComponent>;\r\n  @ContentChildren(KvErrorComponent)\r\n  contentErrors!: QueryList<KvErrorComponent>;\r\n\r\n  constructor(protected readonly componentService: ComponentService) {\r\n    super();\r\n  }\r\n\r\n  public get baseInputClass(): string {\r\n    return `${this.hasError ? 'ng-invalid ng-dirty' : ''} !important`;\r\n  }\r\n\r\n  erroMessage(): string | undefined {\r\n    if (!this.formControl?.errors) return;\r\n\r\n    let message: string = '';\r\n\r\n    if (this.formControl.errors) {\r\n      const objErrors = this.formControl.errors as any;\r\n      if (objErrors.erroMessage) message = objErrors.erroMessage;\r\n    }\r\n\r\n    return message;\r\n  }\r\n\r\n  getName(control: FormControl): string | null {\r\n    return (\r\n      Object.entries(control.parent?.controls ?? []).find(\r\n        ([_, value]) => value === control\r\n      )?.[0] ?? null\r\n    );\r\n  }\r\n\r\n  hasControlError(): boolean {\r\n    if (!this.formControl) return false;\r\n    return (\r\n      (this.formControl.dirty || this.formControl.touched) &&\r\n      this.formControl.errors !== null\r\n    );\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.viewErrors.forEach((c) => {\r\n      c.emitError.subscribe((res) => {\r\n        this.hasError = res;\r\n        this.componentService.changeDetectorRef.detectChanges();\r\n      });\r\n    });\r\n  }\r\n\r\n  ngAfterContentInit() {\r\n    this.contentErrors.forEach((c) => {\r\n      c.emitError.subscribe((res) => {\r\n        this.hasError = res;\r\n      });\r\n    });\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.formControl = this.componentService.getFormControl();\r\n\r\n    if (this.formControl?.errors?.['required']) this.showAsterisk = true;\r\n  }\r\n\r\n  onInputBlur(event: Event) {\r\n    if (this.onTouched) this.onTouched();\r\n\r\n    this.onBlur.emit(event);\r\n  }\r\n\r\n  onInputClose(event: any) {\r\n    this.onClose.emit(event);\r\n  }\r\n\r\n  onInputInput(event: Event) {\r\n    this.onInput.emit(event);\r\n  }\r\n\r\n  protected setPlaceHolder(p: string) {\r\n    if (!this.placeholder) this.placeholder = p;\r\n  }\r\n}\r\n"]}