@gipisistemas/ng-core 1.1.0 → 1.1.2

package/esm5/shared/gipi-components/input-select/input-select.component.js

@@ -0,0 +1,698 @@
+import { __awaiter, __decorate, __generator, __metadata, __read, __spread } from "tslib";
+import { A, ENTER, ESCAPE, NINE, SPACE, Z, ZERO } from '@angular/cdk/keycodes';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, TrackByFunction, ViewChild, forwardRef } from '@angular/core';
+import { FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, map, takeUntil } from 'rxjs/operators';
+import { ObjectUtil } from '../../../core/utils/object.util';
+import { GIPIFormFieldComponent } from '../form-field/form-field.component';
+import { GIPIOverlayComponent } from '../overlay/overlay.component';
+/** A altura dos itens selecionados em unidades `px`. */
+var OPTION_HEIGHT_PX = 40;
+var nextUniqueId = 0;
+var GIPIInputSelectComponent = /** @class */ (function () {
+    function GIPIInputSelectComponent(_changeDetectorRef) {
+        var _this = this;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._name = "gipi-input-select-" + nextUniqueId++;
+        this._onDestroy = new Subject();
+        this._itemSizeScrollViewport = 5;
+        this._overlayVisible = false;
+        this._formControlSearch = new FormControl({ value: '', disabled: false });
+        this.inputFieldValue = '';
+        this.inputFieldValueSelected = 0;
+        this.toggleAllCheckboxChecked = false;
+        this.toggleAllCheckboxIndeterminate = false;
+        this.isLoading = 0;
+        this.id = this._name;
+        this.name = this._name;
+        this.placeholder = 'Selecionar';
+        this.labelSelectAll = 'Selecionar todos';
+        this.multiple = false;
+        // Mostrar/ocultar o botão limpar opções selecionadas
+        this.showClear = false;
+        this.showOnFocus = true;
+        this.hideOnEscape = true;
+        this.showSelectAll = false;
+        this.showFooter = false;
+        this.infiniteScroll = true;
+        this.showSearch = false;
+        this.required = false;
+        this.pageSize = 5;
+        // Input search --------
+        // Ativar limpar input ao pressionar escape
+        this.enableClearOnEscapePressed = true;
+        // ---------------------
+        this._disabled = false;
+        this._loading = false;
+        this.onFocus = new EventEmitter();
+        this.onBlur = new EventEmitter();
+        this.onClose = new EventEmitter();
+        this.onSelectChange = new EventEmitter();
+        this.onOpenedChange = new EventEmitter();
+        this.onSearchChange = new EventEmitter();
+        this.onAddChange = new EventEmitter();
+        this.trackByOption = function (index, obj) { return obj && _this.trackBy && obj[_this.trackBy] ? obj[_this.trackBy] : obj; };
+        this.onChange = function () { };
+        this.onTouch = function () { };
+    }
+    GIPIInputSelectComponent_1 = GIPIInputSelectComponent;
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "disabled", {
+        get: function () {
+            return this._disabled;
+        },
+        set: function (value) {
+            this._disabled = value;
+            this._disableInputSearch();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "loading", {
+        get: function () {
+            return this._loading;
+        },
+        set: function (value) {
+            this._loading = value;
+            this._disableInputSearch();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "paramNextBatch", {
+        get: function () {
+            return this._paramNextBatch;
+        },
+        set: function (val) {
+            this._paramNextBatch = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            this._value = value;
+            if (this.multiple) {
+                if (Array.isArray(value) && value && value.length) {
+                    var firstValue = value[0];
+                    this.inputFieldValue = this.property ? firstValue[this.property] : this.getPropertyValue(firstValue);
+                    this.inputFieldValueSelected = value.length;
+                }
+                else {
+                    this.inputFieldValue = '';
+                    this.inputFieldValueSelected = 0;
+                }
+            }
+            else {
+                if (!Array.isArray(value) && value) {
+                    this.inputFieldValue = this.property ? value[this.property] : this.getPropertyValue(value);
+                    this.inputFieldValueSelected = 0;
+                }
+                else {
+                    this.inputFieldValue = '';
+                    this.inputFieldValueSelected = 0;
+                }
+            }
+            this.onChange(value);
+            this.onSelectChange.emit(value);
+            this.onTouch();
+            this._changeDetectorRef.markForCheck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "options", {
+        get: function () {
+            return this._options;
+        },
+        set: function (val) {
+            this._options = val;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "scrollViewportHeight", {
+        get: function () {
+            var height = 0;
+            if (this.options && this.options.length) {
+                height = (this.options.length * OPTION_HEIGHT_PX) - (this.pageSize === this.options.length ? OPTION_HEIGHT_PX : 0);
+            }
+            if (!ObjectUtil.isNull(this.overlaySelect)) {
+                this.overlaySelect.alignOverlay();
+            }
+            return height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSelectComponent.prototype, "valueSearch", {
+        get: function () {
+            return this._formControlSearch.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIInputSelectComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this._formControlSearch.valueChanges
+            .pipe(map(function (value) { return value; }), debounceTime(1000), distinctUntilChanged(), takeUntil(this._onDestroy))
+            .subscribe(function (value) { return _this._searchChange(value); });
+        this.indeterminateAllCheckbox();
+    };
+    GIPIInputSelectComponent.prototype.ngOnDestroy = function () {
+        this._onDestroy.next();
+        this._onDestroy.complete();
+    };
+    GIPIInputSelectComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    GIPIInputSelectComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouch = fn;
+    };
+    GIPIInputSelectComponent.prototype.writeValue = function (value) {
+        this.value = value;
+    };
+    GIPIInputSelectComponent.prototype.setDisabledState = function (val) {
+        this.disabled = val;
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPIInputSelectComponent.prototype.compareFn = function (f1, f2) {
+        if (!this.property && !this.propertyFn) {
+            throw new Error('O parâmetro property ou propertyFn deve conter um valor');
+        }
+        if (!this.property && this.propertyFn && f1 && f2) {
+            var propF1 = this.getPropertyValue(f1);
+            var propF2 = this.getPropertyValue(f2);
+            return propF1 === propF2;
+        }
+        return f1 && f2 && f1[this.property] === f2[this.property];
+    };
+    GIPIInputSelectComponent.prototype.getPropertyValue = function (entity) {
+        if (!ObjectUtil.isNull(entity)) {
+            if (!ObjectUtil.isNull(this.propertyFn)) {
+                return this.propertyFn(entity);
+            }
+            else if (this.property) {
+                return this._getValue(entity, this.property);
+            }
+        }
+        return '';
+    };
+    GIPIInputSelectComponent.prototype._getValue = function (entity, property) {
+        var properties = property.split('.');
+        var value = entity;
+        for (var i = 0; i < properties.length; i++) {
+            value = Reflect.get(value, properties[i]);
+            if (value && i === properties.length - 1) {
+                return value;
+            }
+        }
+    };
+    GIPIInputSelectComponent.prototype.onInputFocus = function (event) {
+        if (this.showOnFocus && !this.disabled) {
+            this.showOverlay();
+            this.onFocus.emit(event);
+        }
+    };
+    GIPIInputSelectComponent.prototype.onInputClick = function () {
+        if (!this.disabled) {
+            this.showOverlay();
+            if (!this._overlayVisible) {
+                this.formFieldSelect.focus();
+            }
+        }
+    };
+    GIPIInputSelectComponent.prototype.onInputBlur = function (event) {
+        if (!this.disabled) {
+            this.onBlur.emit(event);
+            this.onTouch();
+        }
+    };
+    GIPIInputSelectComponent.prototype.onInputKeydown = function (event) {
+        if (this.disabled) {
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (((event.code.toUpperCase() === 'ESCAPE') && this.hideOnEscape) ||
+            ((event.code.toUpperCase() === 'ENTER') || (event.code.toUpperCase() === 'NUMPADENTER')) ||
+            (event.code.toUpperCase() === 'TAB')) {
+            if (this._overlayVisible) {
+                this.hideOverlay();
+                event.preventDefault();
+            }
+        }
+    };
+    GIPIInputSelectComponent.prototype.onClearOptionsClick = function (event) {
+        if (this.disabled) {
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (this.multiple && Array.isArray(this.value)) {
+            this.value = [];
+        }
+        else {
+            this.value = null;
+        }
+        this.toggleAllCheckboxChecked = false;
+        this.toggleAllCheckboxIndeterminate = false;
+        this._changeDetectorRef.detectChanges();
+        this.onSelectChange.emit(this.value);
+        this._searchSelectInputFocus();
+        event.stopImmediatePropagation();
+    };
+    GIPIInputSelectComponent.prototype.showOverlay = function () {
+        if (!this._overlayVisible) {
+            this._overlayVisible = true;
+            this.indeterminateAllCheckbox();
+            this.onOpenedChange.emit(this._overlayVisible);
+            this._changeDetectorRef.detectChanges();
+            if (ObjectUtil.isNull(this._cache)) {
+                this.onScroll();
+            }
+        }
+    };
+    GIPIInputSelectComponent.prototype.hideOverlay = function () {
+        this._overlayVisible = false;
+        this.onOpenedChange.emit(this._overlayVisible);
+        this._cache = {};
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPIInputSelectComponent.prototype.toggleOverlay = function () {
+        if (this.disabled || this.loading) {
+            return;
+        }
+        else {
+            if (!this._overlayVisible) {
+                this.showOverlay();
+            }
+            else {
+                this.hideOverlay();
+            }
+        }
+    };
+    // Infinite scroll ------------------------------------------------
+    GIPIInputSelectComponent.prototype.onScroll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var pageNumber;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.infiniteScroll) {
+                            return [2 /*return*/];
+                        }
+                        if (ObjectUtil.isNull(this.nextBatchFn)) {
+                            console.error('A função "nextBatchFn" é obrigatória e não foi informada');
+                            return [2 /*return*/];
+                        }
+                        if (!ObjectUtil.isNull(this._pageModel) && (this._pageModel.totalPages === this._pageModel.number)) {
+                            return [2 /*return*/];
+                        }
+                        pageNumber = !ObjectUtil.isNull(this._pageModel) ? this._pageModel.number + 1 : 0;
+                        // Mantemos um índice de páginas carregadas pelo servidor para não carregarmos os mesmos dados duas vezes
+                        // Isso é baseado na página do servidor, não na interface do usuário
+                        if (ObjectUtil.isNull(this._cache)) {
+                            this._cache = {};
+                        }
+                        if (this._cache[pageNumber]) {
+                            return [2 /*return*/];
+                        }
+                        this._cache[pageNumber] = true;
+                        this.isLoading++;
+                        return [4 /*yield*/, this.nextBatchFn(this._formControlSearch.value, pageNumber, this.paramNextBatch).then(function (pagedData) {
+                                _this._pageModel = pagedData;
+                                _this._totalOptions = pagedData.totalElements;
+                                if (!_this.options) {
+                                    _this.options = [];
+                                }
+                                // Deslocamento da linha inicial. Esta é a posição para inserir os novos dados
+                                var start = _this._pageModel.number * _this.pageSize;
+                                // Copiar dados existentes
+                                var options = __spread(_this.options);
+                                // Inserir novas linhas na posição correta
+                                options.splice.apply(options, __spread([start, _this.pageSize], pagedData.content));
+                                // Volta o array de opções ja atualizado para exibição
+                                _this.options = options;
+                                if (_this.toggleAllCheckboxChecked) {
+                                    _this.onChangeToggleAllCheckbox();
+                                }
+                                else {
+                                    _this.indeterminateAllCheckbox();
+                                }
+                                // Diminuir o contador de chamadas de API pendentes
+                                _this.isLoading--;
+                            }, function (error) {
+                                _this.isLoading = 0;
+                            })];
+                    case 1:
+                        _a.sent();
+                        if (!ObjectUtil.isNull(this.cdkVirtualScrollViewPort) && this.options && this.options.length) {
+                            this.cdkVirtualScrollViewPort.scrollToIndex(this.options.length, 'smooth');
+                            this.cdkVirtualScrollViewPort.checkViewportSize();
+                        }
+                        this._changeDetectorRef.detectChanges();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Options --------------------------------------------------------
+    GIPIInputSelectComponent.prototype.onButtonSelectOptionClick = function (option) {
+        if (this.multiple) {
+            if (!this.value) {
+                this.value = [];
+            }
+            if (Array.isArray(this.value)) {
+                var indexOption = this.value.findIndex(function (o) { return ObjectUtil.equals(o, option); });
+                if (indexOption >= 0) {
+                    var lValue = this.value;
+                    lValue.splice(indexOption, 1);
+                    this.value = __spread(lValue);
+                }
+                else {
+                    this.value = __spread(this.value, [option]);
+                }
+            }
+        }
+        else {
+            if (!Array.isArray(this.value)) {
+                this.value = option;
+            }
+        }
+        this.indeterminateAllCheckbox();
+        this.onSelectChange.emit(this.value);
+        this._changeDetectorRef.detectChanges();
+    };
+    GIPIInputSelectComponent.prototype.indeterminateAllCheckbox = function () {
+        if (this.multiple && this.showSelectAll) {
+            if (!Array.isArray(this.value) ||
+                !this.value ||
+                (this.value && !this.value.length) ||
+                !this.options ||
+                (this.options && !this.options.length)) {
+                this.toggleAllCheckboxChecked = false;
+                this.toggleAllCheckboxIndeterminate = false;
+            }
+            if (Array.isArray(this.value)) {
+                if (this.infiniteScroll) {
+                    this.toggleAllCheckboxChecked = this.value && this._pageModel && (this.value.length > 0) && (this._totalOptions > 0) && (this.value.length === this._totalOptions);
+                    this.toggleAllCheckboxIndeterminate = (this.value.length > 0) && (this.value.length < this._totalOptions);
+                }
+                else {
+                    this.toggleAllCheckboxChecked = this.value && (this.value.length > 0) && this.options && (this.options.length > 0) && (this.value.length === this.options.length);
+                    this.toggleAllCheckboxIndeterminate = (this.value.length > 0) && (this.options.length > 0) && (this.value.length < this.options.length);
+                }
+            }
+            this._changeDetectorRef.detectChanges();
+        }
+    };
+    GIPIInputSelectComponent.prototype.optionCheckboxIsChecked = function (option) {
+        if (!this.multiple) {
+            return false;
+        }
+        if (Array.isArray(this.value) && (this.value && this.value.length)) {
+            this._changeDetectorRef.markForCheck();
+            return this.value.findIndex(function (o) { return ObjectUtil.equals(o, option); }) > -1;
+        }
+    };
+    GIPIInputSelectComponent.prototype.onClickSelectAllByOption = function () {
+        if (this.disabled || this.loading) {
+            return;
+        }
+        this.toggleAllCheckboxChecked = !this.toggleAllCheckboxChecked;
+        this.onChangeToggleAllCheckbox();
+    };
+    GIPIInputSelectComponent.prototype.onChangeToggleAllCheckbox = function () {
+        if (this.multiple) {
+            if (this.toggleAllCheckboxChecked) {
+                this.value = __spread(this.options);
+            }
+            else {
+                this.value = [];
+            }
+            this.indeterminateAllCheckbox();
+        }
+    };
+    GIPIInputSelectComponent.prototype.onClickAddOptions = function () {
+        if (this.multiple && !this.showSelectAll) {
+            var addChange = {
+                values: this.value,
+                selectedAll: false
+            };
+            this.onAddChange.emit(addChange);
+        }
+    };
+    // Input search --------------------------------------------------
+    GIPIInputSelectComponent.prototype._disableInputSearch = function () {
+        if (this.disabled || this.loading) {
+            this._formControlSearch.disable();
+        }
+        else {
+            this._formControlSearch.enable();
+        }
+    };
+    GIPIInputSelectComponent.prototype._searchChange = function (value) {
+        if (this._overlayVisible) {
+            this.loading = true;
+            this.onSearchChange.emit(value);
+            this._pageModel = null;
+            this.options = [];
+            this._cache = {};
+            this.onScroll();
+            this.loading = false;
+            this._changeDetectorRef.detectChanges();
+        }
+    };
+    /**
+     * Focaliza o input de pesquisa
+     */
+    GIPIInputSelectComponent.prototype._searchSelectInputFocus = function () {
+        if (ObjectUtil.isNull(this.formfieldSelectSearchInput) || !this._overlayVisible) {
+            return;
+        }
+        // Seta o foco
+        this.formfieldSelectSearchInput.focus();
+    };
+    /**
+     * Redefine o valor do input de pesquisa atual
+     * @param focus se deve focar após a redefinição
+     */
+    GIPIInputSelectComponent.prototype._searchSelectInputReset = function (focus) {
+        this._formControlSearch.setValue('');
+        if (focus) {
+            this._searchSelectInputFocus();
+        }
+    };
+    /**
+     * Manipula o evento de tecla pressionada.
+     * Permite, por ex. selecionando com a tecla enter, navegando com as teclas de seta, etc.
+     * @param event
+     */
+    GIPIInputSelectComponent.prototype.onInputSearchKeydown = function (event) {
+        var _this = this;
+        // Evite a propagação de todos os caracteres alfanuméricos para evitar problemas de seleção
+        if ((event.key && event.key.length === 1) ||
+            (event.keyCode >= A && event.keyCode <= Z) ||
+            (event.keyCode >= ZERO && event.keyCode <= NINE) ||
+            (event.keyCode === SPACE)) {
+            event.stopPropagation();
+        }
+        if (this.multiple && event.key && event.keyCode === ENTER) {
+            // Recupere o foco após a seleção múltipla, para que possamos digitar ainda mais
+            setTimeout(function () { return _this._searchSelectInputFocus(); });
+        }
+        // Caso especial, se clicar em Escape, se a entrada estiver vazia, feche o menu suspenso, caso contrário, esvazie o campo de pesquisa
+        if (this.enableClearOnEscapePressed && (event.keyCode === ESCAPE) && this._formControlSearch.value) {
+            this._searchSelectInputReset(true);
+            event.stopPropagation();
+        }
+    };
+    var GIPIInputSelectComponent_1;
+    GIPIInputSelectComponent.ctorParameters = function () { return [
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        ViewChild('formfieldSelectSearchInput', { read: GIPIFormFieldComponent, static: true }),
+        __metadata("design:type", GIPIFormFieldComponent)
+    ], GIPIInputSelectComponent.prototype, "formfieldSelectSearchInput", void 0);
+    __decorate([
+        ViewChild('formFieldSelect', { read: GIPIFormFieldComponent, static: false }),
+        __metadata("design:type", GIPIFormFieldComponent)
+    ], GIPIInputSelectComponent.prototype, "formFieldSelect", void 0);
+    __decorate([
+        ViewChild('overlaySelect', { read: GIPIOverlayComponent, static: false }),
+        __metadata("design:type", GIPIOverlayComponent)
+    ], GIPIInputSelectComponent.prototype, "overlaySelect", void 0);
+    __decorate([
+        ViewChild(CdkVirtualScrollViewport, { static: false }),
+        __metadata("design:type", CdkVirtualScrollViewport)
+    ], GIPIInputSelectComponent.prototype, "cdkVirtualScrollViewPort", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIInputSelectComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "ariaLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "labelSelectAll", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "multiple", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "showClear", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "showOnFocus", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "hideOnEscape", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "showSelectAll", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "showFooter", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "infiniteScroll", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "showSearch", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "required", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "property", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSelectComponent.prototype, "trackBy", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIInputSelectComponent.prototype, "appendTo", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], GIPIInputSelectComponent.prototype, "propertyFn", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], GIPIInputSelectComponent.prototype, "nextBatchFn", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPIInputSelectComponent.prototype, "pageSize", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSelectComponent.prototype, "enableClearOnEscapePressed", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPIInputSelectComponent.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPIInputSelectComponent.prototype, "loading", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIInputSelectComponent.prototype, "paramNextBatch", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIInputSelectComponent.prototype, "value", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Array),
+        __metadata("design:paramtypes", [Array])
+    ], GIPIInputSelectComponent.prototype, "options", null);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onFocus", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onBlur", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onClose", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onSelectChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onOpenedChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onSearchChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputSelectComponent.prototype, "onAddChange", void 0);
+    GIPIInputSelectComponent = GIPIInputSelectComponent_1 = __decorate([
+        Component({
+            selector: "gipi-input-select",
+            exportAs: 'gipiInputSelect',
+            template: "<gipi-form-field #formFieldSelect\n                 [id]=\"id\"\n                 [name]=\"name\"\n                 [type]=\"'select'\"\n                 [readonly]=\"true\"\n                 [disabled]=\"disabled\"\n                 [required]=\"required\"\n                 [label]=\"label\"\n                 [placeholder]=\"placeholder\"\n                 [showClear]=\"inputFieldValue && showClear && !disabled && !loading\"\n                 [showTrigger]=\"inputFieldValueSelected && (inputFieldValueSelected > 1)\"\n                 [trigger]=\"inputFieldValueSelected\"\n                 [ariaLabel]=\"ariaLabel\"\n                 [(ngModel)]=\"inputFieldValue\"\n                 (onKeydown)=\"onInputKeydown($event)\"\n                 (onClear)=\"onClearOptionsClick($event)\"\n                 (onFocus)=\"onInputFocus($event)\"\n                 (onBlur)=\"onInputBlur($event)\"\n                 (onClick)=\"onInputClick()\">\n</gipi-form-field>\n\n<gipi-overlay *ngIf=\"!disabled && !loading\"\n              contentStyleClass=\"overlay-select\"\n              #overlaySelect\n              [(visible)]=\"_overlayVisible\"\n              [autoZIndex]=\"true\"\n              [appendTo]=\"appendTo ? appendTo : 'body'\"\n              (onShow)=\"onOpenedChange.emit(true)\"\n              (onHide)=\"onOpenedChange.emit(false)\">\n    <div class=\"select-search\"\n         *ngIf=\"showSearch\"\n         [class.disabled]=\"showSelectAll && (disabled || loading || (isLoading > 0))\">\n        <mat-checkbox *ngIf=\"multiple && showSelectAll\"\n                      class=\"select-search-toggle-all-checkbox\"\n                      [disabled]=\"disabled || loading || !options || (options && !options.length)\"\n                      [(ngModel)]=\"toggleAllCheckboxChecked\"\n                      [indeterminate]=\"toggleAllCheckboxIndeterminate\"\n                      (change)=\"onChangeToggleAllCheckbox()\">\n        </mat-checkbox>\n\n        <gipi-form-field #formfieldSelectSearchInput\n                         placeholder=\"Pesquisar\"\n                         type=\"search\"\n                         [style.width]=\"'100%'\"\n                         [formControl]=\"_formControlSearch\"\n                         [showClear]=\"valueSearch && !disabled && !loading && isLoading <= 0\"\n                         (onKeydown)=\"onInputSearchKeydown($event)\">\n        </gipi-form-field>\n    </div>\n\n    <div class=\"select-row select-option-all\"\n         [style.height.px]=\"40\"\n         [class.disabled]=\"disabled || loading\"\n         *ngIf=\"(!showSearch && multiple && showSelectAll)\"\n         (click)=\"onClickSelectAllByOption()\">\n        <mat-pseudo-checkbox *ngIf=\"multiple\"\n                             class=\"select-mat-option-pseudo-checkbox\"\n                             [state]=\"toggleAllCheckboxIndeterminate ? 'indeterminate' : toggleAllCheckboxChecked ? 'checked' : ''\">\n        </mat-pseudo-checkbox>\n\n        <span> {{ labelSelectAll ? labelSelectAll : 'Selecionar todos' }} </span>\n    </div>\n\n    <cdk-virtual-scroll-viewport *ngIf=\"(options && options.length) && (!loading || isLoading <= 0)\"\n                                 class=\"select-virtual-scroll-viewport\"\n                                 [style.height.px]=\"scrollViewportHeight\"\n                                 [itemSize]=\"_itemSizeScrollViewport\"\n                                 GIPIInfiniteScroll\n                                 [infiniteScrollDistance]=\"'30%'\"\n                                 [infiniteScrollThrottle]=\"50\"\n                                 [infiniteScrollcomplete]=\"options && _totalOptions && options.length === _totalOptions\"\n                                 (scrolled)=\"onScroll()\">\n        <div *cdkVirtualFor=\"let option of options; trackBy: trackByOption\"\n             class=\"select-row\"\n             [style.height.px]=\"40\"\n             [class.disabled]=\"disabled || loading\"\n             (click)=\"onButtonSelectOptionClick(option)\">\n            <mat-pseudo-checkbox *ngIf=\"multiple && option\"\n                                 class=\"select-mat-option-pseudo-checkbox\"\n                                 [state]=\"optionCheckboxIsChecked(option) ? 'checked' : ''\">\n            </mat-pseudo-checkbox>\n\n            <span> {{ option ? getPropertyValue(option) : '' }} </span>\n        </div>\n    </cdk-virtual-scroll-viewport>\n\n    <div *ngIf=\"loading || isLoading > 0\"\n         class=\"select-loading\">\n        <div class=\"dot-pulse\"> </div>\n    </div>\n\n    <div *ngIf=\"(!options || (options && options.length <= 0)) && !loading && (isLoading <= 0)\"\n         class=\"select-not-found\">\n        <mat-icon>sentiment_very_dissatisfied</mat-icon>\n        Nenhum registro foi encontrado\n    </div>\n\n    <div class=\"select-footer\"\n         *ngIf=\"multiple && !showSelectAll && showFooter\">\n        <gipi-button label=\"Adicionar\"\n                     gipi-primary\n                     id=\"btnAddOptions\"\n                     [style.width]=\"'100%'\"\n                     [disabled]=\"disabled || loading || (!value || (value && !value.length))\"\n                     (click)=\"onClickAddOptions()\">\n        </gipi-button>\n    </div>\n</gipi-overlay>\n",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPIInputSelectComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-input-select',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: ["::ng-deep .overlay-select{padding:0!important;overflow:hidden!important}::ng-deep .select-virtual-scroll-viewport{width:100%!important;max-height:240px;overflow:auto}::ng-deep .select-virtual-scroll-viewport .cdk-virtual-scroll-content-wrapper{width:100%!important;position:relative!important}::ng-deep .select-virtual-scroll-viewport::-webkit-scrollbar{width:15px}::ng-deep .select-virtual-scroll-viewport::-webkit-scrollbar-thumb{background-color:#e0e1e2;border-radius:10px;border:4px solid transparent;background-clip:padding-box}::ng-deep .select-row{display:flex;align-items:center;padding:0 16px;cursor:pointer;font-size:1.4rem;line-height:100%;gap:12px}::ng-deep .select-row:hover{background:#f5f5f6}::ng-deep .select-row:active{background:#e0e1e2}::ng-deep .select-row.disabled{background-color:#d1d2d4!important;color:#9a9da2!important;cursor:not-allowed!important;pointer-events:none!important}::ng-deep .select-row>span{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.select-search{display:flex;align-items:center;font-size:1.4rem;line-height:100%;gap:12px;padding:8px 12px}.select-option-all{border-bottom:1px solid rgba(0,0,0,.12)}.select-not-found{display:flex;flex-direction:column;align-items:center;justify-content:center;font-weight:600;font-size:1.2rem;gap:8px;color:#131313;cursor:default;padding:0 0 16px}.select-not-found>mat-icon{width:2.8rem;height:2.8rem;font-size:2.8rem;line-height:2.8rem;color:#131313}.select-loading{height:4rem;width:100%;background-color:#fff;display:flex;align-items:center;justify-content:center}.select-loading .dot-pulse{position:relative;left:-9999px;width:5px;height:5px;border-radius:50%;background-color:#e0313e;color:#e0313e;box-shadow:9999px 0 0 -5px;-webkit-animation:1.5s linear .25s infinite dot-pulse;animation:1.5s linear .25s infinite dot-pulse}.select-loading .dot-pulse::after,.select-loading .dot-pulse::before{content:\"\";display:inline-block;position:absolute;top:0;width:5px;height:5px;border-radius:50%;background-color:#e0313e;color:#e0313e}.select-loading .dot-pulse::before{box-shadow:9984px 0 0 -5px;-webkit-animation:1.5s linear infinite dot-pulse-before;animation:1.5s linear infinite dot-pulse-before}.select-loading .dot-pulse::after{box-shadow:10014px 0 0 -5px;-webkit-animation:1.5s linear .5s infinite dot-pulse-after;animation:1.5s linear .5s infinite dot-pulse-after}@-webkit-keyframes dot-pulse-before{0%,100%,60%{box-shadow:9984px 0 0 -5px}30%{box-shadow:9984px 0 0 2px}}@keyframes dot-pulse-before{0%,100%,60%{box-shadow:9984px 0 0 -5px}30%{box-shadow:9984px 0 0 2px}}@-webkit-keyframes dot-pulse{0%,100%,60%{box-shadow:9999px 0 0 -5px}30%{box-shadow:9999px 0 0 2px}}@keyframes dot-pulse{0%,100%,60%{box-shadow:9999px 0 0 -5px}30%{box-shadow:9999px 0 0 2px}}@-webkit-keyframes dot-pulse-after{0%,100%,60%{box-shadow:10014px 0 0 -5px}30%{box-shadow:10014px 0 0 2px}}@keyframes dot-pulse-after{0%,100%,60%{box-shadow:10014px 0 0 -5px}30%{box-shadow:10014px 0 0 2px}}.select-footer{display:flex;align-items:center;gap:12px;padding:8px 12px;border-top:1px solid #bfbfbf}::ng-deep .select-mat-option-pseudo-checkbox{margin:0!important}"]
+        }),
+        __metadata("design:paramtypes", [ChangeDetectorRef])
+    ], GIPIInputSelectComponent);
+    return GIPIInputSelectComponent;
+}());
+export { GIPIInputSelectComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-select.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/input-select/input-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { A, ENTER, ESCAPE, NINE, SPACE, Z, ZERO } from '@angular/cdk/keycodes';\nimport { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, TrackByFunction, ViewChild, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { Subject } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, map, takeUntil } from 'rxjs/operators';\n\nimport { PageDTO } from '../../../core/models/dto/page.dto';\nimport { ObjectUtil } from '../../../core/utils/object.util';\nimport { GIPIFormFieldComponent } from '../form-field/form-field.component';\nimport { GIPIOverlayComponent } from '../overlay/overlay.component';\n\nexport interface AddChange<T> {\n    values: T | T[];\n    selectedAll?: boolean;\n}\n\n/** A altura dos itens selecionados em unidades `px`. */\nconst OPTION_HEIGHT_PX = 40;\n\nlet nextUniqueId = 0;\n\n@Component({\n    selector: `gipi-input-select`,\n    exportAs: 'gipiInputSelect',\n    templateUrl: './input-select.component.html',\n    styleUrls: ['./input-select.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof GIPIInputSelectComponent => GIPIInputSelectComponent),\n            multi: true\n        }\n    ],\n    host: {\n        'class': 'gipi-input-select',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class GIPIInputSelectComponent<T> implements OnInit, ControlValueAccessor {\n\n    private _name: string = `gipi-input-select-${nextUniqueId++}`;\n\n    private _cache: any;\n\n    private _pageModel: PageDTO<T>;\n\n    private _onDestroy: Subject<void> = new Subject<void>();\n\n    _itemSizeScrollViewport: number = 5;\n\n    _totalOptions: number;\n\n    _overlayVisible: boolean = false;\n\n    _formControlSearch: FormControl = new FormControl({ value: '', disabled: false });\n\n    inputFieldValue: string = '';\n\n    inputFieldValueSelected: number = 0;\n\n    toggleAllCheckboxChecked: boolean = false;\n    toggleAllCheckboxIndeterminate: boolean = false;\n\n    isLoading: number = 0;\n\n    // @ViewChild('searchSelectInput', { read: ElementRef, static: true }) searchSelectInput: ElementRef;\n    @ViewChild('formfieldSelectSearchInput', { read: GIPIFormFieldComponent, static: true }) formfieldSelectSearchInput: GIPIFormFieldComponent;\n\n    @ViewChild('formFieldSelect', { read: GIPIFormFieldComponent, static: false }) formFieldSelect: GIPIFormFieldComponent;\n\n    @ViewChild('overlaySelect', { read: GIPIOverlayComponent, static: false }) overlaySelect: GIPIOverlayComponent;\n\n    @ViewChild(CdkVirtualScrollViewport, { static: false }) private cdkVirtualScrollViewPort: CdkVirtualScrollViewport;\n\n    @Input() id: string | number = this._name;\n\n    @Input() name: string = this._name;\n\n    @Input() ariaLabel: string;\n\n    @Input() label: string;\n\n    @Input() placeholder: string = 'Selecionar';\n\n    @Input() labelSelectAll: string = 'Selecionar todos';\n\n    @Input() multiple: boolean = false;\n\n    // Mostrar/ocultar o botão limpar opções selecionadas\n    @Input() showClear: boolean = false;\n\n    @Input() showOnFocus: boolean = true;\n\n    @Input() hideOnEscape: boolean = true;\n\n    @Input() showSelectAll: boolean = false;\n\n    @Input() showFooter: boolean = false;\n\n    @Input() infiniteScroll: boolean = true;\n\n    @Input() showSearch: boolean = false;\n\n    @Input() required: boolean = false;\n\n    @Input() property: string;\n\n    @Input() trackBy: string;\n\n    @Input() appendTo: any;\n\n    @Input() propertyFn: (obj: T) => string;\n\n    @Input() nextBatchFn!: (researchField: string, page: number, paramNextBatch?: any) => Promise<PageDTO<T>>;\n\n    @Input() pageSize: number = 5;\n\n    // Input search --------\n    // Ativar limpar input ao pressionar escape\n    @Input() enableClearOnEscapePressed: boolean = true;\n    // ---------------------\n\n    private _disabled: boolean = false;\n    @Input() set disabled(value: boolean) {\n        this._disabled = value;\n        this._disableInputSearch();\n    }\n    get disabled(): boolean {\n        return this._disabled;\n    }\n\n    private _loading: boolean = false;\n    @Input() set loading(value: boolean) {\n        this._loading = value;\n        this._disableInputSearch();\n    }\n    get loading(): boolean {\n        return this._loading;\n    }\n\n    private _paramNextBatch: any;\n    @Input() set paramNextBatch(val: any) {\n        this._paramNextBatch = val;\n    }\n    get paramNextBatch(): any {\n        return this._paramNextBatch;\n    }\n\n    private _value: T | T[];\n    @Input() set value(value: T | T[]) {\n        this._value = value;\n\n        if (this.multiple) {\n            if (Array.isArray(value) && value && value.length) {\n                const firstValue = value[0];\n                this.inputFieldValue = this.property ? firstValue[this.property] : this.getPropertyValue(firstValue);\n                this.inputFieldValueSelected = value.length;\n            } else {\n                this.inputFieldValue = '';\n                this.inputFieldValueSelected = 0;\n            }\n\n        } else {\n            if (!Array.isArray(value) && value) {\n                this.inputFieldValue = this.property ? value[this.property] : this.getPropertyValue(value);\n                this.inputFieldValueSelected = 0;\n            } else {\n                this.inputFieldValue = '';\n                this.inputFieldValueSelected = 0;\n            }\n        }\n\n        this.onChange(value);\n        this.onSelectChange.emit(value);\n        this.onTouch();\n        this._changeDetectorRef.markForCheck();\n    }\n    get value(): T | T[] {\n        return this._value;\n    }\n\n    private _options: T[];\n    @Input() set options(val: T[]) {\n        this._options = val;\n    }\n    get options(): T[] {\n        return this._options;\n    }\n\n    @Output() onFocus: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onBlur: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onClose: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onSelectChange: EventEmitter<T | T[]> = new EventEmitter<T | T[]>();\n    @Output() onOpenedChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n    @Output() onSearchChange: EventEmitter<string> = new EventEmitter<string>();\n    @Output() onAddChange: EventEmitter<AddChange<T>> = new EventEmitter<AddChange<T>>();\n\n    get scrollViewportHeight(): number {\n        let height: number = 0;\n        if (this.options && this.options.length) {\n            height = (this.options.length * OPTION_HEIGHT_PX) - (this.pageSize === this.options.length ? OPTION_HEIGHT_PX : 0);\n        }\n\n        if (!ObjectUtil.isNull(this.overlaySelect)) {\n            this.overlaySelect.alignOverlay();\n        }\n\n        return height;\n    }\n\n    get valueSearch(): string {\n        return this._formControlSearch.value;\n    }\n\n    constructor(private _changeDetectorRef: ChangeDetectorRef) { }\n\n    ngOnInit() {\n        this._formControlSearch.valueChanges\n            .pipe(\n                map((value: string): string => value),\n                debounceTime(1000),\n                distinctUntilChanged(),\n                takeUntil(this._onDestroy)\n            )\n            .subscribe((value: string): void => this._searchChange(value));\n\n        this.indeterminateAllCheckbox();\n    }\n\n    ngOnDestroy(): void {\n        this._onDestroy.next();\n        this._onDestroy.complete();\n    }\n\n    trackByOption: TrackByFunction<T> = (index, obj) => obj && this.trackBy && obj[this.trackBy] ? obj[this.trackBy] : obj;\n\n    onChange: any = (): void => { };\n\n    onTouch: any = (): void => { };\n\n    registerOnChange(fn: any): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouch = fn;\n    }\n\n    writeValue(value: any): void {\n        this.value = value;\n    }\n\n    setDisabledState(val: boolean): void {\n        this.disabled = val;\n        this._changeDetectorRef.markForCheck();\n    }\n\n    compareFn(f1: T, f2: T): boolean {\n        if (!this.property && !this.propertyFn) {\n            throw new Error('O parâmetro property ou propertyFn deve conter um valor');\n        }\n\n        if (!this.property && this.propertyFn && f1 && f2) {\n            const propF1 = this.getPropertyValue(f1);\n            const propF2 = this.getPropertyValue(f2);\n            return propF1 === propF2;\n        }\n\n        return f1 && f2 && f1[this.property] === f2[this.property];\n    }\n\n    public getPropertyValue(entity: T): string {\n        if (!ObjectUtil.isNull(entity)) {\n            if (!ObjectUtil.isNull(this.propertyFn)) {\n                return this.propertyFn(entity);\n            } else if (this.property) {\n                return this._getValue(entity, this.property);\n            }\n        }\n        return '';\n    }\n\n    private _getValue(entity: T, property: string): string {\n        const properties: string[] = property.split('.');\n        let value: any = entity;\n\n        for (let i: number = 0; i < properties.length; i++) {\n            value = Reflect.get(value, properties[i]);\n            if (value && i === properties.length - 1) {\n                return value;\n            }\n        }\n    }\n\n    public onInputFocus(event: Event): void {\n        if (this.showOnFocus && !this.disabled) {\n            this.showOverlay();\n            this.onFocus.emit(event);\n        }\n    }\n\n    public onInputClick(): void {\n        if (!this.disabled) {\n            this.showOverlay();\n\n            if (!this._overlayVisible) {\n                this.formFieldSelect.focus();\n            }\n        }\n    }\n\n    public onInputBlur(event: Event): void {\n        if (!this.disabled) {\n            this.onBlur.emit(event);\n            this.onTouch();\n        }\n    }\n\n    public onInputKeydown(event: any): void {\n        if (this.disabled) {\n            event.stopImmediatePropagation();\n            return;\n        }\n\n        if (\n            ((event.code.toUpperCase() === 'ESCAPE') && this.hideOnEscape) ||\n            ((event.code.toUpperCase() === 'ENTER') || (event.code.toUpperCase() === 'NUMPADENTER')) ||\n            (event.code.toUpperCase() === 'TAB')\n        ) {\n            if (this._overlayVisible) {\n                this.hideOverlay();\n                event.preventDefault();\n            }\n        }\n    }\n\n    public onClearOptionsClick(event: Event): void {\n        if (this.disabled) {\n            event.stopImmediatePropagation();\n            return;\n        }\n\n        if (this.multiple && Array.isArray(this.value)) {\n            this.value = [];\n        } else {\n            this.value = null;\n        }\n\n        this.toggleAllCheckboxChecked = false;\n        this.toggleAllCheckboxIndeterminate = false;\n        this._changeDetectorRef.detectChanges();\n        this.onSelectChange.emit(this.value);\n\n        this._searchSelectInputFocus();\n        event.stopImmediatePropagation();\n    }\n\n    public showOverlay(): void {\n        if (!this._overlayVisible) {\n            this._overlayVisible = true;\n            this.indeterminateAllCheckbox();\n            this.onOpenedChange.emit(this._overlayVisible);\n            this._changeDetectorRef.detectChanges();\n\n            if (ObjectUtil.isNull(this._cache)) {\n                this.onScroll();\n            }\n        }\n    }\n\n    public hideOverlay(): void {\n        this._overlayVisible = false;\n        this.onOpenedChange.emit(this._overlayVisible);\n        this._cache = {};\n        this._changeDetectorRef.markForCheck();\n    }\n\n    public toggleOverlay(): void {\n        if (this.disabled || this.loading) {\n            return;\n        } else {\n            if (!this._overlayVisible) {\n                this.showOverlay();\n            } else {\n                this.hideOverlay();\n            }\n        }\n    }\n\n    // Infinite scroll ------------------------------------------------\n    async onScroll() {\n        if (!this.infiniteScroll) {\n            return;\n        }\n        if (ObjectUtil.isNull(this.nextBatchFn)) {\n            console.error('A função \"nextBatchFn\" é obrigatória e não foi informada');\n            return;\n        }\n        if (!ObjectUtil.isNull(this._pageModel) && (this._pageModel.totalPages === this._pageModel.number)) {\n            return;\n        }\n\n        const pageNumber: number = !ObjectUtil.isNull(this._pageModel) ? this._pageModel.number + 1 : 0;\n\n        // Mantemos um índice de páginas carregadas pelo servidor para não carregarmos os mesmos dados duas vezes\n        // Isso é baseado na página do servidor, não na interface do usuário\n        if (ObjectUtil.isNull(this._cache)) {\n            this._cache = {};\n        }\n        if (this._cache[pageNumber]) {\n            return;\n        }\n        this._cache[pageNumber] = true;\n\n        this.isLoading++;\n\n        await this.nextBatchFn(this._formControlSearch.value, pageNumber, this.paramNextBatch).then(pagedData => {\n            this._pageModel = pagedData;\n            this._totalOptions = pagedData.totalElements;\n\n            if (!this.options) {\n                this.options = [];\n            }\n\n            // Deslocamento da linha inicial. Esta é a posição para inserir os novos dados\n            const start = this._pageModel.number * this.pageSize;\n\n            // Copiar dados existentes\n            const options = [...this.options];\n\n            // Inserir novas linhas na posição correta\n            options.splice(start, this.pageSize, ...pagedData.content);\n\n            // Volta o array de opções ja atualizado para exibição\n            this.options = options;\n\n            if (this.toggleAllCheckboxChecked) {\n                this.onChangeToggleAllCheckbox();\n            } else {\n                this.indeterminateAllCheckbox();\n            }\n\n\n            // Diminuir o contador de chamadas de API pendentes\n            this.isLoading--;\n        }, error => {\n            this.isLoading = 0;\n        });\n\n        if (!ObjectUtil.isNull(this.cdkVirtualScrollViewPort) && this.options && this.options.length) {\n            this.cdkVirtualScrollViewPort.scrollToIndex(this.options.length, 'smooth');\n            this.cdkVirtualScrollViewPort.checkViewportSize();\n        }\n\n        this._changeDetectorRef.detectChanges();\n    }\n\n    // Options --------------------------------------------------------\n    public onButtonSelectOptionClick(option: T): void {\n        if (this.multiple) {\n            if (!this.value) {\n                this.value = [];\n            }\n\n            if (Array.isArray(this.value)) {\n                const indexOption: number = this.value.findIndex(o => ObjectUtil.equals(o, option));\n                if (indexOption >= 0) {\n                    const lValue = this.value;\n                    lValue.splice(indexOption, 1);\n                    this.value = [...lValue];\n                } else {\n                    this.value = [...this.value, option];\n                }\n            }\n        } else {\n            if (!Array.isArray(this.value)) {\n                this.value = option;\n            }\n        }\n\n        this.indeterminateAllCheckbox();\n\n        this.onSelectChange.emit(this.value);\n        this._changeDetectorRef.detectChanges();\n    }\n\n    public indeterminateAllCheckbox(): void {\n        if (this.multiple && this.showSelectAll) {\n            if (\n                !Array.isArray(this.value) ||\n                !this.value ||\n                (this.value && !this.value.length) ||\n                !this.options ||\n                (this.options && !this.options.length)\n            ) {\n                this.toggleAllCheckboxChecked = false;\n                this.toggleAllCheckboxIndeterminate = false;\n            }\n\n            if (Array.isArray(this.value)) {\n                if (this.infiniteScroll) {\n                    this.toggleAllCheckboxChecked = this.value && this._pageModel && (this.value.length > 0) && (this._totalOptions > 0) && (this.value.length === this._totalOptions);\n                    this.toggleAllCheckboxIndeterminate = (this.value.length > 0) && (this.value.length < this._totalOptions);\n                } else {\n                    this.toggleAllCheckboxChecked = this.value && (this.value.length > 0) && this.options && (this.options.length > 0) && (this.value.length === this.options.length);\n                    this.toggleAllCheckboxIndeterminate = (this.value.length > 0) && (this.options.length > 0) && (this.value.length < this.options.length);\n                }\n            }\n\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n\n    public optionCheckboxIsChecked(option: T): boolean {\n        if (!this.multiple) {\n            return false;\n        }\n\n        if (Array.isArray(this.value) && (this.value && this.value.length)) {\n            this._changeDetectorRef.markForCheck();\n            return this.value.findIndex(o => ObjectUtil.equals(o, option)) > -1;\n        }\n    }\n\n    public onClickSelectAllByOption(): void {\n        if (this.disabled || this.loading) {\n            return;\n        }\n\n        this.toggleAllCheckboxChecked = !this.toggleAllCheckboxChecked;\n        this.onChangeToggleAllCheckbox();\n    }\n\n    public onChangeToggleAllCheckbox(): void {\n        if (this.multiple) {\n            if (this.toggleAllCheckboxChecked) {\n                this.value = [...this.options];\n            } else {\n                this.value = [];\n            }\n\n            this.indeterminateAllCheckbox();\n        }\n    }\n\n    public onClickAddOptions(): void {\n        if (this.multiple && !this.showSelectAll) {\n            const addChange: AddChange<T> = {\n                values: this.value,\n                selectedAll: false\n            };\n            this.onAddChange.emit(addChange);\n        }\n    }\n\n    // Input search --------------------------------------------------\n    private _disableInputSearch(): void {\n        if (this.disabled || this.loading) {\n            this._formControlSearch.disable();\n        } else {\n            this._formControlSearch.enable();\n        }\n    }\n\n    private _searchChange(value: string): void {\n        if (this._overlayVisible) {\n            this.loading = true;\n            this.onSearchChange.emit(value);\n\n            this._pageModel = null;\n            this.options = [];\n            this._cache = {};\n\n            this.onScroll();\n            this.loading = false;\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n\n    /**\n     * Focaliza o input de pesquisa\n     */\n    public _searchSelectInputFocus(): void {\n        if (ObjectUtil.isNull(this.formfieldSelectSearchInput) || !this._overlayVisible) {\n            return;\n        }\n        // Seta o foco\n        this.formfieldSelectSearchInput.focus();\n    }\n\n    /**\n     * Redefine o valor do input de pesquisa atual\n     * @param focus se deve focar após a redefinição\n     */\n    public _searchSelectInputReset(focus?: boolean): void {\n        this._formControlSearch.setValue('');\n        if (focus) {\n            this._searchSelectInputFocus();\n        }\n    }\n\n    /**\n     * Manipula o evento de tecla pressionada.\n     * Permite, por ex. selecionando com a tecla enter, navegando com as teclas de seta, etc.\n     * @param event\n     */\n    public onInputSearchKeydown(event: KeyboardEvent): void {\n        // Evite a propagação de todos os caracteres alfanuméricos para evitar problemas de seleção\n        if (\n            (event.key && event.key.length === 1) ||\n            (event.keyCode >= A && event.keyCode <= Z) ||\n            (event.keyCode >= ZERO && event.keyCode <= NINE) ||\n            (event.keyCode === SPACE)\n        ) {\n            event.stopPropagation();\n        }\n\n        if (this.multiple && event.key && event.keyCode === ENTER) {\n            // Recupere o foco após a seleção múltipla, para que possamos digitar ainda mais\n            setTimeout((): void => this._searchSelectInputFocus());\n        }\n\n        // Caso especial, se clicar em Escape, se a entrada estiver vazia, feche o menu suspenso, caso contrário, esvazie o campo de pesquisa\n        if (this.enableClearOnEscapePressed && (event.keyCode === ESCAPE) && this._formControlSearch.value) {\n            this._searchSelectInputReset(true);\n            event.stopPropagation();\n        }\n    }\n\n}\n"]}