@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm5/shared/components/select-entity-paged/shared/select-search/select-search.component.js

@@ -0,0 +1,590 @@
+import { __decorate, __metadata, __param, __read, __values } from "tslib";
+import { A, DOWN_ARROW, END, ENTER, ESCAPE, HOME, NINE, SPACE, UP_ARROW, Z, ZERO } from '@angular/cdk/keycodes';
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ElementRef, EventEmitter, HostBinding, Inject, Input, OnChanges, OnDestroy, OnInit, Optional, Output, QueryList, SimpleChanges, ViewChild, forwardRef } from '@angular/core';
+import { FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatFormField, MatOption, MatSelect } from '@angular/material';
+import { BehaviorSubject, Subject, combineLatest, of } from 'rxjs';
+import { delay, filter, map, startWith, switchMap, take, takeUntil, tap } from 'rxjs/operators';
+import { ITSS_SELECT_SEARCH_DEFAULT_OPTIONS, configurableDefaultOptions } from '../default-options';
+import { SelectNoEntriesFoundDirective } from '../select-no-entries-found.directive';
+import { SelectSearchClearDirective } from '../select-search-clear.directive';
+/**
+ * Este componente foi reescrito utilizando se do projeto a seguir
+ * https://github.com/bithost-gmbh/ngx-mat-select-search
+ */
+var SelectSearchComponent = /** @class */ (function () {
+    function SelectSearchComponent(matSelect, changeDetectorRef, _viewportRuler, matOption, matFormField, defaultOptions) {
+        var _this = this;
+        if (matOption === void 0) { matOption = null; }
+        if (matFormField === void 0) { matFormField = null; }
+        this.matSelect = matSelect;
+        this.changeDetectorRef = changeDetectorRef;
+        this._viewportRuler = _viewportRuler;
+        this.matOption = matOption;
+        this.matFormField = matFormField;
+        // Rótulo do marcador de posição de pesquisa
+        this.placeholderLabel = 'Pesquisar...';
+        // Tipo do campo de entrada de pesquisa
+        this.type = 'text';
+        // Ícone baseado em fonte usado para exibir Close-Icon
+        this.closeIcon = 'close';
+        // Rótulo a ser mostrado quando nenhuma entrada for encontrada. Defina como nulo se nenhuma mensagem deve ser mostrada
+        this.noEntriesFoundLabel = 'Nenhum resultado encontrado';
+        /**
+         * Se o campo de pesquisa deve ou não ser limpo após o menu suspenso ser fechado.
+         * Útil para filtragem do lado do servidor. Veja [#3](https://github.com/bithost-gmbh/ngx-mat-select-search/issues/3)
+         */
+        this.clearSearchInput = true;
+        // Se deve mostrar o indicador de pesquisa em andamento
+        this.searching = false;
+        // Desativa o foco inicial do campo de entrada
+        this.disableInitialFocus = false;
+        // Ativar limpar input ao pressionar escape
+        this.enableClearOnEscapePressed = false;
+        /**
+         * Impede que a chave home/end seja propagada para mat-select,
+         * permitindo mover o cursor dentro da entrada de pesquisa em vez de navegar pelas opções
+         */
+        this.preventHomeEndKeyPropagation = false;
+        // Desativa a rolagem para as opções ativas quando a lista de opções é alterada. Útil para pesquisa do lado do servidor
+        this.disableScrollToActiveOnOptionsChanged = false;
+        // Adiciona suporte a leitor de tela 508 para caixa de pesquisa
+        this.ariaLabel = 'Pesquisa suspensa';
+        // Se deve mostrar a caixa de seleção Selecionar tudo (para mat-select[multi=true])
+        this.showToggleAllCheckbox = false;
+        // Selecione tudo caixa de seleção marcada estado
+        this._toggleAllCheckboxChecked = false;
+        // Marque todas as caixas de seleção estado indeterminado
+        this._toggleAllCheckboxIndeterminate = false;
+        // Exibir uma mensagem em uma dica de ferramenta na caixa de seleção de alternar tudo
+        this.toggleAllCheckboxTooltipMessage = '';
+        // Defina a posição da dica de ferramenta na caixa de seleção de alternar tudo.
+        this.toggleAllCheckboxTooltipPosition = 'below';
+        // Mostrar/ocultar o botão limpar pesquisa da entrada de pesquisa
+        this.hideClearSearchButton = false;
+        /**
+         * Sempre restaure as opções selecionadas na seleção Altere para o modo multi (por exemplo, para carregamento lento/rolagem infinita).
+         * O padrão é falso, portanto, as opções selecionadas são restauradas apenas enquanto a filtragem está ativa.
+         */
+        this.alwaysRestoreSelectedOptionsMulti = false;
+        // Emissor de saída para enviar ao componente pai com a alternância de todos os booleanos
+        this.toggleAll = new EventEmitter();
+        this.toggleAllIndeterminate = new EventEmitter();
+        this._options$ = new BehaviorSubject(null);
+        this.optionsList$ = this._options$.pipe(switchMap(function (_options) { return _options
+            ? _options.changes.pipe(map(function (options) { return options.toArray(); }), startWith(_options.toArray()))
+            : of(null); }));
+        this.optionsLength$ = this.optionsList$.pipe(map(function (options) { return options ? options.length : 0; }));
+        this._formControl = new FormControl('');
+        // Se deve mostrar a mensagem sem entradas encontradas
+        this._showNoEntriesFound$ = combineLatest([
+            this._formControl.valueChanges,
+            this.optionsLength$
+        ]).pipe(map(function (_a) {
+            var _b = __read(_a, 2), value = _b[0], optionsLength = _b[1];
+            return _this.noEntriesFoundLabel && value
+                && optionsLength === _this.getOptionsLengthOffset();
+        }));
+        // Subject emitido quando o componente foi destruído
+        this._onDestroy = new Subject();
+        this.onTouched = function (_) { };
+        this.applyDefaultOptions(defaultOptions);
+    }
+    SelectSearchComponent_1 = SelectSearchComponent;
+    Object.defineProperty(SelectSearchComponent.prototype, "value", {
+        // Valor de pesquisa atual
+        get: function () {
+            return this._formControl.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SelectSearchComponent.prototype, "_options", {
+        get: function () {
+            return this._options$.getValue();
+        },
+        // Referência às opções MatSelect
+        set: function (_options) {
+            this._options$.next(_options);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SelectSearchComponent.prototype, "isInsideMatOption", {
+        // Adiciona a classe mat-select-search-inside-mat-option se o itss-select-search estiver
+        // dentro do mat-option
+        get: function () {
+            return !!this.matOption;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SelectSearchComponent.prototype, "toggleAllCheckboxChecked", {
+        get: function () {
+            return this._toggleAllCheckboxChecked;
+        },
+        set: function (value) {
+            this._toggleAllCheckboxChecked = value;
+            this.toggleAll.emit(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SelectSearchComponent.prototype, "toggleAllCheckboxIndeterminate", {
+        get: function () {
+            return this._toggleAllCheckboxIndeterminate;
+        },
+        set: function (value) {
+            this._toggleAllCheckboxIndeterminate = value;
+            this.toggleAllIndeterminate.emit(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SelectSearchComponent.prototype.applyDefaultOptions = function (defaultOptions) {
+        var e_1, _a;
+        if (!defaultOptions) {
+            return;
+        }
+        try {
+            for (var configurableDefaultOptions_1 = __values(configurableDefaultOptions), configurableDefaultOptions_1_1 = configurableDefaultOptions_1.next(); !configurableDefaultOptions_1_1.done; configurableDefaultOptions_1_1 = configurableDefaultOptions_1.next()) {
+                var key = configurableDefaultOptions_1_1.value;
+                if (defaultOptions.hasOwnProperty(key)) {
+                    this[key] = defaultOptions[key];
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (configurableDefaultOptions_1_1 && !configurableDefaultOptions_1_1.done && (_a = configurableDefaultOptions_1.return)) _a.call(configurableDefaultOptions_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    SelectSearchComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        // Definir classe de opção mat personalizada se o componente foi colocado dentro de uma opção mat
+        if (this.matOption) {
+            this.matOption.disabled = true;
+            this.matOption._getHostElement().classList.add('contains-mat-select-search');
+            this.matOption._getHostElement().setAttribute('aria-hidden', 'true');
+        }
+        else {
+            console.error('<itss-input-search> deve ser colocado dentro de um elemento <mat-option>');
+        }
+        // Quando o painel suspenso de seleção é aberto ou fechado
+        this.matSelect.openedChange
+            .pipe(delay(1), takeUntil(this._onDestroy))
+            .subscribe(function (opened) {
+            if (opened) {
+                _this.updateInputWidth();
+                // Focar o campo de pesquisa ao abrir
+                if (!_this.disableInitialFocus) {
+                    _this._focus();
+                }
+            }
+            else {
+                // Limpá-lo ao fechar
+                if (_this.clearSearchInput) {
+                    _this._reset();
+                }
+            }
+        });
+        // Definir o primeiro item ativo após as opções alteradas
+        this.matSelect.openedChange
+            .pipe(take(1), switchMap(function () {
+            _this._options = _this.matSelect.options;
+            // Variável de fechamento para rastrear a primeira opção mais recente.
+            // Para evitar que a lista role para o topo quando as opções são adicionadas ao final da lista
+            // (por exemplo: rolagem infinita), comparamos apenas as alterações nas primeiras opções para
+            // determinar se devemos definir o primeiro item como ativo. Isso evita a rolagem desnecessária
+            // para o topo da lista quando as opções são anexadas, mas permite que o primeiro item da lista
+            // seja definido como ativo por padrão quando não há seleção ativa.
+            var previousFirstOption = _this._options.toArray()[_this.getOptionsLengthOffset()];
+            return _this._options.changes
+                .pipe(tap(function () {
+                // Evitar o erro "expression has been changed"
+                setTimeout(function () {
+                    // Converter a QueryList em uma matriz
+                    var options = _this._options.toArray();
+                    // O verdadeiro primeiro item é compensado por 1
+                    var currentFirstOption = options[_this.getOptionsLengthOffset()];
+                    var keyManager = _this.matSelect._keyManager;
+                    if (keyManager && _this.matSelect.panelOpen) {
+                        // Definir primeiro item ativo e largura de entrada
+                        // Verifique se a primeira opção nessas alterações é diferente da anterior.
+                        var firstOptionIsChanged = !_this.matSelect.compareWith(previousFirstOption, currentFirstOption);
+                        // CASO: A primeira opção é diferente agora.
+                        // Indica que devemos defini-lo como ativo e rolar para o topo.
+                        if (firstOptionIsChanged
+                            || !keyManager.activeItem
+                            || !options.find(function (option) { return _this.matSelect.compareWith(option, keyManager.activeItem); })) {
+                            keyManager.setFirstItemActive();
+                        }
+                        // Aguarde as alterações na largura do painel
+                        setTimeout(function () {
+                            _this.updateInputWidth();
+                        });
+                    }
+                    // Atualize nossa referência
+                    previousFirstOption = currentFirstOption;
+                });
+            }));
+        }))
+            .pipe(takeUntil(this._onDestroy))
+            .subscribe();
+        // Adicione ou remova a classe css dependendo se deseja mostrar a mensagem sem entradas encontradas
+        // obs: isso é hacky
+        this._showNoEntriesFound$.pipe(takeUntil(this._onDestroy)).subscribe(function (showNoEntriesFound) {
+            // Definir nenhuma classe de entrada encontrada na mat-option
+            if (_this.matOption) {
+                if (showNoEntriesFound) {
+                    _this.matOption._getHostElement().classList.add('mat-select-search-no-entries-found');
+                }
+                else {
+                    _this.matOption._getHostElement().classList.remove('mat-select-search-no-entries-found');
+                }
+            }
+        });
+        // Redimensione a largura de entrada quando a viewport for redimensionada,
+        // ou seja, a largura do acionador pode ser redimensionada.
+        this._viewportRuler.change()
+            .pipe(takeUntil(this._onDestroy))
+            .subscribe(function () {
+            if (_this.matSelect.panelOpen) {
+                _this.updateInputWidth();
+            }
+        });
+        this.initMultipleHandling();
+        this.optionsList$.pipe(takeUntil(this._onDestroy)).subscribe(function () {
+            // Atualizar visualização quando as opções disponíveis mudarem
+            _this.changeDetectorRef.markForCheck();
+        });
+    };
+    SelectSearchComponent.prototype.ngOnChanges = function (changes) {
+        if (this.searching) {
+            this._formControl.disable();
+        }
+        else {
+            this._formControl.enable();
+            this._focus();
+        }
+    };
+    SelectSearchComponent.prototype.ngOnDestroy = function () {
+        this._onDestroy.next();
+        this._onDestroy.complete();
+    };
+    SelectSearchComponent.prototype._isToggleAllCheckboxVisible = function () {
+        return this.matSelect.multiple && this.showToggleAllCheckbox;
+    };
+    /**
+     * Manipula o evento de tecla pressionada com MatSelect.
+     * Permite, por ex. selecionando com a tecla enter, navegando com as teclas de seta, etc.
+     * @param event
+     */
+    SelectSearchComponent.prototype._handleKeydown = 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)
+            || (this.preventHomeEndKeyPropagation && (event.keyCode === HOME || event.keyCode === END))) {
+            event.stopPropagation();
+        }
+        if (this.matSelect.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._focus(); });
+        }
+        // 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 === true && event.keyCode === ESCAPE && this.value) {
+            this._reset(true);
+            event.stopPropagation();
+        }
+    };
+    /**
+     * Manipula o evento de ativação de chave com MatSelect.
+     * Permite, por ex. o anúncio do Descendente atualmente ativo por leitores de tela.
+     */
+    SelectSearchComponent.prototype._handleKeyup = function (event) {
+        if (event.keyCode === UP_ARROW || event.keyCode === DOWN_ARROW) {
+            var ariaActiveDescendantId_1 = this.matSelect._getAriaActiveDescendant();
+            var index = this._options.toArray().findIndex(function (item) { return item.id === ariaActiveDescendantId_1; });
+            if (index !== -1) {
+                this.unselectActiveDescendant();
+                this.activeDescendant = this._options.toArray()[index]._getHostElement();
+                this.activeDescendant.setAttribute('aria-selected', 'true');
+                this.searchSelectInput.nativeElement.setAttribute('aria-activedescendant', ariaActiveDescendantId_1);
+            }
+        }
+    };
+    SelectSearchComponent.prototype.writeValue = function (value) {
+        this._lastExternalInputValue = value;
+        this._formControl.setValue(value);
+        this.changeDetectorRef.markForCheck();
+    };
+    SelectSearchComponent.prototype.onBlur = function () {
+        this.unselectActiveDescendant();
+        this.onTouched();
+    };
+    SelectSearchComponent.prototype.registerOnChange = function (fn) {
+        var _this = this;
+        this._formControl.valueChanges.pipe(filter(function (value) { return value !== _this._lastExternalInputValue; }), tap(function () { return _this._lastExternalInputValue = undefined; }), takeUntil(this._onDestroy)).subscribe(fn);
+    };
+    SelectSearchComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    /**
+     * Focaliza o campo de entrada de pesquisa
+     */
+    SelectSearchComponent.prototype._focus = function () {
+        if (!this.searchSelectInput || !this.matSelect.panel) {
+            return;
+        }
+        // salve e restaure o scrollTop do painel, pois será redefinido por focus ()
+        // obs: isso é hacky
+        var panel = this.matSelect.panel.nativeElement;
+        var scrollTop = panel.scrollTop;
+        // Seta o foco
+        this.searchSelectInput.nativeElement.focus();
+        panel.scrollTop = scrollTop;
+    };
+    /**
+     * Redefine o valor de pesquisa atual
+     * @param focus se deve focar após a redefinição
+     */
+    SelectSearchComponent.prototype._reset = function (focus) {
+        this._formControl.setValue('');
+        if (focus) {
+            this._focus();
+        }
+    };
+    /**
+     * Inicializa a manipulação <mat-select [multiple]="true">
+     * Nota: para melhorar este código, mat-select deve ser estendido para permitir desabilitar a redefinição da seleção durante a filtragem.
+     */
+    SelectSearchComponent.prototype.initMultipleHandling = function () {
+        var _this = this;
+        if (!this.matSelect.ngControl) {
+            if (this.matSelect.multiple) {
+                // nota: o acesso a matSelect.ngControl (em vez de matSelect.value / matSelect.valueChanges)
+                // é necessário para funcionar corretamente no modo de seleção múltipla.
+                console.error('o mat-select contendo itss-input-search deve ter uma diretiva ngModel ou formControl quando multiple=true');
+            }
+            return;
+        }
+        // Se <mat-select [multiple]="true">
+        // armazenar valores previamente selecionados e restaurá-los quando forem desmarcados
+        // porque a opção não está disponível enquanto estamos filtrando
+        this.previousSelectedValues = this.matSelect.ngControl.value;
+        this.matSelect.ngControl.valueChanges
+            .pipe(takeUntil(this._onDestroy))
+            .subscribe(function (values) {
+            var restoreSelectedValues = false;
+            if (_this.matSelect.multiple) {
+                if ((_this.alwaysRestoreSelectedOptionsMulti || (_this._formControl.value && _this._formControl.value.length))
+                    && _this.previousSelectedValues && Array.isArray(_this.previousSelectedValues)) {
+                    if (!values || !Array.isArray(values)) {
+                        values = [];
+                    }
+                    var optionValues_1 = _this.matSelect.options.map(function (option) { return option.value; });
+                    _this.previousSelectedValues.forEach(function (previousValue) {
+                        if (!values.some(function (v) { return _this.matSelect.compareWith(v, previousValue); })
+                            && !optionValues_1.some(function (v) { return _this.matSelect.compareWith(v, previousValue); })) {
+                            // Se um valor que foi selecionado antes for desmarcado e não encontrado nas opções, ele foi desmarcado
+                            // devido à filtragem, então restauramos.
+                            values.push(previousValue);
+                            restoreSelectedValues = true;
+                        }
+                    });
+                }
+            }
+            _this.previousSelectedValues = values;
+            if (restoreSelectedValues) {
+                _this.matSelect._onChange(values);
+            }
+        });
+    };
+    /**
+     *  Defina a largura do innerSelectSearch para ajustar até mesmo as barras de rolagem personalizadas
+     *  E apoiar todos os sistemas de operação
+     */
+    SelectSearchComponent.prototype.updateInputWidth = function () {
+        if (!this.innerSelectSearch || !this.innerSelectSearch.nativeElement) {
+            return;
+        }
+        var element = this.innerSelectSearch.nativeElement;
+        var panelElement;
+        while (element = element.parentElement) {
+            if (element.classList.contains('mat-select-panel')) {
+                panelElement = element;
+                break;
+            }
+        }
+        if (panelElement) {
+            this.innerSelectSearch.nativeElement.style.width = panelElement.clientWidth + 'px';
+        }
+    };
+    /**
+     * Determine o deslocamento para o comprimento que pode ser causado pelo matOption opcional usado como uma entrada de pesquisa.
+     */
+    SelectSearchComponent.prototype.getOptionsLengthOffset = function () {
+        if (this.matOption) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    };
+    SelectSearchComponent.prototype.unselectActiveDescendant = function () {
+        if (this.activeDescendant) {
+            this.activeDescendant.removeAttribute('aria-selected');
+        }
+        this.searchSelectInput.nativeElement.removeAttribute('aria-activedescendant');
+    };
+    var SelectSearchComponent_1;
+    SelectSearchComponent.ctorParameters = function () { return [
+        { type: MatSelect, decorators: [{ type: Inject, args: [MatSelect,] }] },
+        { type: ChangeDetectorRef },
+        { type: ViewportRuler },
+        { type: MatOption, decorators: [{ type: Optional }, { type: Inject, args: [MatOption,] }] },
+        { type: MatFormField, decorators: [{ type: Optional }, { type: Inject, args: [MatFormField,] }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [ITSS_SELECT_SEARCH_DEFAULT_OPTIONS,] }] }
+    ]; };
+    __decorate([
+        HostBinding('class.mat-select-search-inside-mat-option'),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [])
+    ], SelectSearchComponent.prototype, "isInsideMatOption", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "placeholderLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "type", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "closeIcon", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "closeSvgIcon", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "noEntriesFoundLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "clearSearchInput", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "searching", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "disableInitialFocus", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "enableClearOnEscapePressed", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "preventHomeEndKeyPropagation", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "disableScrollToActiveOnOptionsChanged", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "ariaLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "showToggleAllCheckbox", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], SelectSearchComponent.prototype, "toggleAllCheckboxChecked", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], SelectSearchComponent.prototype, "toggleAllCheckboxIndeterminate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "toggleAllCheckboxTooltipMessage", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], SelectSearchComponent.prototype, "toggleAllCheckboxTooltipPosition", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "hideClearSearchButton", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], SelectSearchComponent.prototype, "alwaysRestoreSelectedOptionsMulti", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], SelectSearchComponent.prototype, "toggleAll", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], SelectSearchComponent.prototype, "toggleAllIndeterminate", void 0);
+    __decorate([
+        ViewChild('searchSelectInput', { read: ElementRef, static: true }),
+        __metadata("design:type", ElementRef)
+    ], SelectSearchComponent.prototype, "searchSelectInput", void 0);
+    __decorate([
+        ViewChild('innerSelectSearch', { read: ElementRef, static: true }),
+        __metadata("design:type", ElementRef)
+    ], SelectSearchComponent.prototype, "innerSelectSearch", void 0);
+    __decorate([
+        ContentChild(SelectSearchClearDirective, { static: false }),
+        __metadata("design:type", SelectSearchClearDirective)
+    ], SelectSearchComponent.prototype, "clearIcon", void 0);
+    __decorate([
+        ContentChild(SelectNoEntriesFoundDirective, { static: false }),
+        __metadata("design:type", SelectNoEntriesFoundDirective)
+    ], SelectSearchComponent.prototype, "noEntriesFound", void 0);
+    SelectSearchComponent = SelectSearchComponent_1 = __decorate([
+        Component({
+            selector: 'itss-input-search',
+            template: "<!-- Espa\u00E7o reservado para ajustar o deslocamento vertical dos elementos mat-option -->\n<input matInput\n       class=\"mat-select-search-input mat-select-search-hidden\" />\n\n<!-- Note: o mat-datepicker-content mat-tab-header \u00E9 necess\u00E1rio para herdar as cores do tema do material, consulte PR n\u00BA 22 -->\n<div #innerSelectSearch\n     class=\"mat-select-search-inner mat-typography mat-datepicker-content mat-tab-header\"\n     [ngClass]=\"{'mat-select-search-inner-multiple': matSelect.multiple, 'mat-select-search-inner-toggle-all': _isToggleAllCheckboxVisible() }\">\n\n    <mat-checkbox *ngIf=\"_isToggleAllCheckboxVisible()\"\n                  class=\"mat-select-search-toggle-all-checkbox\"\n                  color=\"primary\"\n                  [color]=\"matFormField?.color\"\n                  [disabled]=\"searching\"\n                  [matTooltip]=\"toggleAllCheckboxTooltipMessage\"\n                  matTooltipClass=\"ngx-mat-select-search-toggle-all-tooltip\"\n                  [matTooltipPosition]=\"toggleAllCheckboxTooltipPosition\"\n                  [(ngModel)]=\"toggleAllCheckboxChecked\"\n                  [(indeterminate)]=\"toggleAllCheckboxIndeterminate\">\n    </mat-checkbox>\n\n    <input class=\"mat-select-search-input mat-input-element\"\n           autocomplete=\"off\"\n           [type]=\"type\"\n           [formControl]=\"_formControl\"\n           #searchSelectInput\n           (keydown)=\"_handleKeydown($event)\"\n           (keyup)=\"_handleKeyup($event)\"\n           (blur)=\"onBlur()\"\n           [placeholder]=\"placeholderLabel\"\n           [attr.aria-label]=\"ariaLabel\">\n\n    <mat-spinner *ngIf=\"searching\"\n                 class=\"mat-select-search-spinner\"\n                 diameter=\"16\">\n    </mat-spinner>\n\n    <button *ngIf=\"!hideClearSearchButton && value && !searching\"\n            mat-icon-button\n            aria-label=\"Clear\"\n            (click)=\"_reset(true)\"\n            class=\"mat-select-search-clear\">\n        <ng-content *ngIf=\"clearIcon; else defaultIcon\"\n                    select=\"[itssSelectSearchClear]\">\n        </ng-content>\n\n        <ng-template #defaultIcon>\n            <mat-icon [svgIcon]=\"closeSvgIcon\">\n                {{ !closeSvgIcon ? closeIcon : null }}\n            </mat-icon>\n        </ng-template>\n    </button>\n\n    <ng-content select=\".mat-select-search-custom-header-content\"> </ng-content>\n\n    <mat-divider> </mat-divider>\n</div>\n\n<div *ngIf=\"(_showNoEntriesFound$ | async) && !searching\"\n     class=\"mat-select-search-no-entries-found\">\n    <ng-content *ngIf=\"noEntriesFound; else defaultNoEntriesFound\"\n                select=\"[itssSelectNoEntriesFound]\">\n    </ng-content>\n\n    <ng-template #defaultNoEntriesFound>\n        {{ noEntriesFoundLabel }}\n    </ng-template>\n</div>\n",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return SelectSearchComponent_1; }),
+                    multi: true
+                }
+            ],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: ["@charset \"UTF-8\";.mat-select-search-hidden{visibility:hidden}.mat-select-search-inner{position:absolute;top:0;left:0;width:100%;height:3em;border-bottom:none!important;z-index:100;font-size:inherit;box-shadow:none;border-radius:4px 4px 0 0}.mat-select-search-inner.mat-select-search-inner-multiple{width:100%}.mat-select-search-inner.mat-select-search-inner-multiple.mat-select-search-inner-toggle-all{display:flex;align-items:center}.mat-select-search-inner .mat-input-element{flex-basis:auto}.mat-select-search-inner .mat-input-element:-ms-input-placeholder{-ms-user-select:text}::ng-deep .mat-select-search-panel{transform:none!important;overflow-x:hidden}.mat-select-search-input{padding:16px 44px 16px 16px;box-sizing:border-box;width:100%}:host-context([dir=rtl]) .mat-select-search-input{padding-right:16px;padding-left:44px}.mat-select-search-no-entries-found{padding:16px}.mat-select-search-clear{position:absolute;right:4px;top:0}:host-context([dir=rtl]) .mat-select-search-clear{right:auto;left:4px}.mat-select-search-spinner{position:absolute;right:16px;top:calc(50% - 8px)}:host-context([dir=rtl]) .mat-select-search-spinner{right:auto;left:16px}:host.mat-select-search-inside-mat-option .mat-select-search-input{padding-top:0;padding-bottom:0;height:3em;line-height:3em}:host.mat-select-search-inside-mat-option .mat-select-search-clear{top:0}::ng-deep .mat-option[aria-disabled=true].contains-mat-select-search{position:-webkit-sticky;position:sticky;top:0;padding:0;left:0;z-index:1;border-bottom:1px solid rgba(0,0,0,.12)}::ng-deep .mat-option[aria-disabled=true].contains-mat-select-search .mat-icon{margin-right:0;margin-left:0}::ng-deep .mat-option[aria-disabled=true].contains-mat-select-search .mat-option-pseudo-checkbox{display:none}::ng-deep .mat-option[aria-disabled=true].contains-mat-select-search.mat-select-search-no-entries-found{height:6em}.mat-select-search-toggle-all-checkbox{padding-left:16px;padding-bottom:2px}:host-context([dir=rtl]) .mat-select-search-toggle-all-checkbox{padding-left:0;padding-right:16px}:host ::ng-deep .mat-checkbox-checked.mat-primary .mat-checkbox-background,:host ::ng-deep .mat-checkbox-indeterminate.mat-primary .mat-checkbox-background{background-color:#f3465c!important}.mat-select-search-loading{height:3em;width:100%;padding:0;display:flex;flex-direction:row;align-items:center;justify-content:center}.dot-pulse{position:relative;left:-9999px;width:5px;height:5px;border-radius:50%;background-color:#f3465c;color:#f3465c;box-shadow:9999px 0 0 -5px;-webkit-animation:1.5s linear .25s infinite dot-pulse;animation:1.5s linear .25s infinite dot-pulse}.dot-pulse::after,.dot-pulse::before{content:\"\";display:inline-block;position:absolute;top:0;width:5px;height:5px;border-radius:50%;background-color:#f3465c;color:#f3465c}.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}.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}}"]
+        }),
+        __param(0, Inject(MatSelect)),
+        __param(3, Optional()), __param(3, Inject(MatOption)),
+        __param(4, Optional()), __param(4, Inject(MatFormField)),
+        __param(5, Optional()), __param(5, Inject(ITSS_SELECT_SEARCH_DEFAULT_OPTIONS)),
+        __metadata("design:paramtypes", [MatSelect,
+            ChangeDetectorRef,
+            ViewportRuler,
+            MatOption,
+            MatFormField, Object])
+    ], SelectSearchComponent);
+    return SelectSearchComponent;
+}());
+export { SelectSearchComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-search.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/components/select-entity-paged/shared/select-search/select-search.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport { A, DOWN_ARROW, END, ENTER, ESCAPE, HOME, NINE, SPACE, UP_ARROW, Z, ZERO } from '@angular/cdk/keycodes';\nimport { ViewportRuler } from '@angular/cdk/scrolling';\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ElementRef, EventEmitter, HostBinding, Inject, Input, OnChanges, OnDestroy, OnInit, Optional, Output, QueryList, SimpleChanges, ViewChild, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { MatFormField, MatOption, MatSelect } from '@angular/material';\nimport { BehaviorSubject, Observable, Subject, combineLatest, of } from 'rxjs';\nimport { delay, filter, map, startWith, switchMap, take, takeUntil, tap } from 'rxjs/operators';\n\nimport { ITSS_SELECT_SEARCH_DEFAULT_OPTIONS, ItssSelectSearchOptions, configurableDefaultOptions } from '../default-options';\nimport { SelectNoEntriesFoundDirective } from '../select-no-entries-found.directive';\nimport { SelectSearchClearDirective } from '../select-search-clear.directive';\n\n/**\n * Este componente foi reescrito utilizando se do projeto a seguir\n * https://github.com/bithost-gmbh/ngx-mat-select-search\n */\n@Component({\n    selector: 'itss-input-search',\n    templateUrl: './select-search.component.html',\n    styleUrls: ['./select-search.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof SelectSearchComponent => SelectSearchComponent),\n            multi: true\n        }\n    ],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class SelectSearchComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {\n\n    // Valor de pesquisa atual\n    get value(): string {\n        return this._formControl.value;\n    }\n\n    // Referência às opções MatSelect\n    public set _options(_options: QueryList<MatOption>) {\n        this._options$.next(_options);\n    }\n    public get _options(): QueryList<MatOption> {\n        return this._options$.getValue();\n    }\n\n    // Adiciona a classe mat-select-search-inside-mat-option se o itss-select-search estiver\n    // dentro do mat-option\n    @HostBinding('class.mat-select-search-inside-mat-option')\n    get isInsideMatOption(): boolean {\n        return !!this.matOption;\n    }\n\n    constructor(\n        @Inject(MatSelect) public matSelect: MatSelect,\n        public changeDetectorRef: ChangeDetectorRef,\n        private _viewportRuler: ViewportRuler,\n        @Optional() @Inject(MatOption) public matOption: MatOption = null,\n        @Optional() @Inject(MatFormField) public matFormField: MatFormField = null,\n        @Optional() @Inject(ITSS_SELECT_SEARCH_DEFAULT_OPTIONS) defaultOptions?: ItssSelectSearchOptions\n    ) {\n        this.applyDefaultOptions(defaultOptions);\n    }\n\n    // Rótulo do marcador de posição de pesquisa\n    @Input() placeholderLabel: string = 'Pesquisar...';\n\n    // Tipo do campo de entrada de pesquisa\n    @Input() type: string = 'text';\n\n    // Ícone baseado em fonte usado para exibir Close-Icon\n    @Input() closeIcon: string = 'close';\n\n    // Ícone baseado em Svg usado para exibir Close-Icon. Se definido, Close-Icon é substituído\n    @Input() closeSvgIcon?: string;\n\n    // Rótulo a ser mostrado quando nenhuma entrada for encontrada. Defina como nulo se nenhuma mensagem deve ser mostrada\n    @Input() noEntriesFoundLabel: string = 'Nenhum resultado encontrado';\n\n    /**\n     * Se o campo de pesquisa deve ou não ser limpo após o menu suspenso ser fechado.\n     * Útil para filtragem do lado do servidor. Veja [#3](https://github.com/bithost-gmbh/ngx-mat-select-search/issues/3)\n     */\n    @Input() clearSearchInput: boolean = true;\n\n    // Se deve mostrar o indicador de pesquisa em andamento\n    @Input() searching: boolean = false;\n\n    // Desativa o foco inicial do campo de entrada\n    @Input() disableInitialFocus: boolean = false;\n\n    // Ativar limpar input ao pressionar escape\n    @Input() enableClearOnEscapePressed: boolean = false;\n\n    /**\n     * Impede que a chave home/end seja propagada para mat-select,\n     * permitindo mover o cursor dentro da entrada de pesquisa em vez de navegar pelas opções\n     */\n    @Input() preventHomeEndKeyPropagation: boolean = false;\n\n    // Desativa a rolagem para as opções ativas quando a lista de opções é alterada. Útil para pesquisa do lado do servidor\n    @Input() disableScrollToActiveOnOptionsChanged: boolean = false;\n\n    // Adiciona suporte a leitor de tela 508 para caixa de pesquisa\n    @Input() ariaLabel: string = 'Pesquisa suspensa';\n\n    // Se deve mostrar a caixa de seleção Selecionar tudo (para mat-select[multi=true])\n    @Input() showToggleAllCheckbox: boolean = false;\n\n    // Selecione tudo caixa de seleção marcada estado\n    private _toggleAllCheckboxChecked: boolean = false;\n    @Input() set toggleAllCheckboxChecked(value: boolean) {\n        this._toggleAllCheckboxChecked = value;\n        this.toggleAll.emit(value);\n    }\n    get toggleAllCheckboxChecked(): boolean {\n        return this._toggleAllCheckboxChecked;\n    }\n\n    // Marque todas as caixas de seleção estado indeterminado\n    private _toggleAllCheckboxIndeterminate: boolean = false;\n    @Input() set toggleAllCheckboxIndeterminate(value: boolean) {\n        this._toggleAllCheckboxIndeterminate = value;\n        this.toggleAllIndeterminate.emit(value);\n    }\n    get toggleAllCheckboxIndeterminate(): boolean {\n        return this._toggleAllCheckboxIndeterminate;\n    }\n\n    // Exibir uma mensagem em uma dica de ferramenta na caixa de seleção de alternar tudo\n    @Input() toggleAllCheckboxTooltipMessage: string = '';\n\n    // Defina a posição da dica de ferramenta na caixa de seleção de alternar tudo.\n    @Input() toggleAllCheckboxTooltipPosition: 'left' | 'right' | 'above' | 'below' | 'before' | 'after' = 'below';\n\n    // Mostrar/ocultar o botão limpar pesquisa da entrada de pesquisa\n    @Input() hideClearSearchButton: boolean = false;\n\n    /**\n     * Sempre restaure as opções selecionadas na seleção Altere para o modo multi (por exemplo, para carregamento lento/rolagem infinita).\n     * O padrão é falso, portanto, as opções selecionadas são restauradas apenas enquanto a filtragem está ativa.\n     */\n    @Input() alwaysRestoreSelectedOptionsMulti: boolean = false;\n\n    // Emissor de saída para enviar ao componente pai com a alternância de todos os booleanos\n    @Output() toggleAll: EventEmitter<boolean> = new EventEmitter<boolean>();\n    @Output() toggleAllIndeterminate: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n    // Referência ao campo de entrada de pesquisa\n    @ViewChild('searchSelectInput', { read: ElementRef, static: true }) searchSelectInput: ElementRef;\n\n    // Referência ao campo de entrada de pesquisa\n    @ViewChild('innerSelectSearch', { read: ElementRef, static: true }) innerSelectSearch: ElementRef;\n\n    // Referência ao ícone claro de entrada de pesquisa personalizada\n    @ContentChild(SelectSearchClearDirective, { static: false }) clearIcon: SelectSearchClearDirective;\n\n    // Referência ao elemento personalizado sem entradas encontradas\n    @ContentChild(SelectNoEntriesFoundDirective, { static: false }) noEntriesFound: SelectNoEntriesFoundDirective;\n    private _lastExternalInputValue: string;\n    public _options$: BehaviorSubject<QueryList<MatOption>> = new BehaviorSubject<QueryList<MatOption>>(null);\n\n    private optionsList$: Observable<MatOption[]> = this._options$.pipe(\n        switchMap((_options: QueryList<MatOption>): Observable<any> => _options\n            ? _options.changes.pipe(\n                map((options: any): any => options.toArray()),\n                startWith<MatOption[]>(_options.toArray()),)\n            : of(null)\n        )\n    );\n\n    private optionsLength$: Observable<number> = this.optionsList$.pipe(\n        map((options: MatOption[]): number => options ? options.length : 0)\n    );\n\n    // Valores previamente selecionados ao usar <mat-select [multiple]=\"true\">\n    private previousSelectedValues: any[];\n\n    public _formControl: FormControl = new FormControl('');\n\n    // Se deve mostrar a mensagem sem entradas encontradas\n    public _showNoEntriesFound$: Observable<boolean> = combineLatest([\n        this._formControl.valueChanges,\n        this.optionsLength$\n    ]).pipe(\n        map(([value, optionsLength]: [any, number]): boolean => this.noEntriesFoundLabel && value\n            && optionsLength === this.getOptionsLengthOffset())\n    );\n\n    // Subject emitido quando o componente foi destruído\n    private _onDestroy: Subject<void> = new Subject<void>();\n\n    // Referência ao descendente ativo para suporte ARIA.\n    private activeDescendant: HTMLElement;\n\n    private applyDefaultOptions(defaultOptions: ItssSelectSearchOptions): void {\n        if (!defaultOptions) {\n            return;\n        }\n\n        for (const key of configurableDefaultOptions) {\n            if (defaultOptions.hasOwnProperty(key)) {\n                (this[key] as any) = defaultOptions[key];\n            }\n        }\n    }\n\n    ngOnInit(): void {\n        // Definir classe de opção mat personalizada se o componente foi colocado dentro de uma opção mat\n        if (this.matOption) {\n            this.matOption.disabled = true;\n            this.matOption._getHostElement().classList.add('contains-mat-select-search');\n            this.matOption._getHostElement().setAttribute('aria-hidden', 'true');\n        } else {\n            console.error('<itss-input-search> deve ser colocado dentro de um elemento <mat-option>');\n        }\n\n        // Quando o painel suspenso de seleção é aberto ou fechado\n        this.matSelect.openedChange\n            .pipe(\n                delay(1),\n                takeUntil(this._onDestroy)\n            )\n            .subscribe((opened: boolean): void => {\n                if (opened) {\n                    this.updateInputWidth();\n\n                    // Focar o campo de pesquisa ao abrir\n                    if (!this.disableInitialFocus) {\n                        this._focus();\n                    }\n                } else {\n                    // Limpá-lo ao fechar\n                    if (this.clearSearchInput) {\n                        this._reset();\n                    }\n                }\n            });\n\n        // Definir o primeiro item ativo após as opções alteradas\n        this.matSelect.openedChange\n            .pipe(\n                take(1),\n                switchMap((): Observable<any> => {\n                    this._options = this.matSelect.options;\n\n                    // Variável de fechamento para rastrear a primeira opção mais recente.\n                    // Para evitar que a lista role para o topo quando as opções são adicionadas ao final da lista\n                    // (por exemplo: rolagem infinita), comparamos apenas as alterações nas primeiras opções para\n                    // determinar se devemos definir o primeiro item como ativo. Isso evita a rolagem desnecessária\n                    // para o topo da lista quando as opções são anexadas, mas permite que o primeiro item da lista\n                    // seja definido como ativo por padrão quando não há seleção ativa.\n                    let previousFirstOption: MatOption = this._options.toArray()[this.getOptionsLengthOffset()];\n\n                    return this._options.changes\n                        .pipe(\n                            tap((): void => {\n                                // Evitar o erro \"expression has been changed\"\n                                setTimeout((): void => {\n                                    // Converter a QueryList em uma matriz\n                                    const options: MatOption[] = this._options.toArray();\n\n                                    // O verdadeiro primeiro item é compensado por 1\n                                    const currentFirstOption: MatOption = options[this.getOptionsLengthOffset()];\n\n                                    const keyManager: ActiveDescendantKeyManager<MatOption> = this.matSelect._keyManager;\n                                    if (keyManager && this.matSelect.panelOpen) {\n\n                                        // Definir primeiro item ativo e largura de entrada\n\n                                        // Verifique se a primeira opção nessas alterações é diferente da anterior.\n                                        const firstOptionIsChanged: boolean = !this.matSelect.compareWith(previousFirstOption, currentFirstOption);\n\n                                        // CASO: A primeira opção é diferente agora.\n                                        // Indica que devemos defini-lo como ativo e rolar para o topo.\n                                        if (firstOptionIsChanged\n                                            || !keyManager.activeItem\n                                            || !options.find((option: MatOption): boolean => this.matSelect.compareWith(option, keyManager.activeItem))) {\n                                            keyManager.setFirstItemActive();\n                                        }\n\n                                        // Aguarde as alterações na largura do painel\n                                        setTimeout((): void => {\n                                            this.updateInputWidth();\n                                        });\n                                    }\n\n                                    // Atualize nossa referência\n                                    previousFirstOption = currentFirstOption;\n                                });\n                            })\n                        );\n                })\n            )\n            .pipe(takeUntil(this._onDestroy))\n            .subscribe();\n\n        // Adicione ou remova a classe css dependendo se deseja mostrar a mensagem sem entradas encontradas\n        // obs: isso é hacky\n        this._showNoEntriesFound$.pipe(\n            takeUntil(this._onDestroy)\n        ).subscribe((showNoEntriesFound: boolean): void => {\n            // Definir nenhuma classe de entrada encontrada na mat-option\n            if (this.matOption) {\n                if (showNoEntriesFound) {\n                    this.matOption._getHostElement().classList.add('mat-select-search-no-entries-found');\n                } else {\n                    this.matOption._getHostElement().classList.remove('mat-select-search-no-entries-found');\n                }\n            }\n        });\n\n        // Redimensione a largura de entrada quando a viewport for redimensionada,\n        // ou seja, a largura do acionador pode ser redimensionada.\n        this._viewportRuler.change()\n            .pipe(takeUntil(this._onDestroy))\n            .subscribe((): void => {\n                if (this.matSelect.panelOpen) {\n                    this.updateInputWidth();\n                }\n            });\n\n        this.initMultipleHandling();\n\n        this.optionsList$.pipe(\n            takeUntil(this._onDestroy)\n        ).subscribe((): void => {\n            // Atualizar visualização quando as opções disponíveis mudarem\n            this.changeDetectorRef.markForCheck();\n        });\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (this.searching) {\n            this._formControl.disable();\n        } else {\n            this._formControl.enable();\n            this._focus();\n        }\n    }\n\n    ngOnDestroy(): void {\n        this._onDestroy.next();\n        this._onDestroy.complete();\n    }\n\n    onTouched: Function = (_: any): void => { };\n\n    _isToggleAllCheckboxVisible(): boolean {\n        return this.matSelect.multiple && this.showToggleAllCheckbox;\n    }\n\n    /**\n     * Manipula o evento de tecla pressionada com MatSelect.\n     * Permite, por ex. selecionando com a tecla enter, navegando com as teclas de seta, etc.\n     * @param event\n     */\n    _handleKeydown(event: KeyboardEvent): void {\n        // Evite a propagação de todos os caracteres alfanuméricos para evitar problemas de seleção\n        if ((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            || (this.preventHomeEndKeyPropagation && (event.keyCode === HOME || event.keyCode === END))\n        ) {\n            event.stopPropagation();\n        }\n\n        if (this.matSelect.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._focus());\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 === true && event.keyCode === ESCAPE && this.value) {\n            this._reset(true);\n            event.stopPropagation();\n        }\n    }\n\n    /**\n     * Manipula o evento de ativação de chave com MatSelect.\n     * Permite, por ex. o anúncio do Descendente atualmente ativo por leitores de tela.\n     */\n    _handleKeyup(event: KeyboardEvent): void {\n        if (event.keyCode === UP_ARROW || event.keyCode === DOWN_ARROW) {\n            const ariaActiveDescendantId: string = this.matSelect._getAriaActiveDescendant();\n            const index: number = this._options.toArray().findIndex((item: MatOption): boolean => item.id === ariaActiveDescendantId);\n            if (index !== -1) {\n                this.unselectActiveDescendant();\n                this.activeDescendant = this._options.toArray()[index]._getHostElement();\n                this.activeDescendant.setAttribute('aria-selected', 'true');\n                this.searchSelectInput.nativeElement.setAttribute('aria-activedescendant', ariaActiveDescendantId);\n            }\n        }\n    }\n\n    writeValue(value: string): void {\n        this._lastExternalInputValue = value;\n        this._formControl.setValue(value);\n        this.changeDetectorRef.markForCheck();\n    }\n\n    onBlur(): void {\n        this.unselectActiveDescendant();\n        this.onTouched();\n    }\n\n    registerOnChange(fn: (value: string) => void): void {\n        this._formControl.valueChanges.pipe(\n            filter((value: any): boolean => value !== this._lastExternalInputValue),\n            tap((): any => this._lastExternalInputValue = undefined),\n            takeUntil(this._onDestroy)\n        ).subscribe(fn);\n    }\n\n    registerOnTouched(fn: Function): void {\n        this.onTouched = fn;\n    }\n\n    /**\n     * Focaliza o campo de entrada de pesquisa\n     */\n    public _focus(): void {\n        if (!this.searchSelectInput || !this.matSelect.panel) {\n            return;\n        }\n        // salve e restaure o scrollTop do painel, pois será redefinido por focus ()\n        // obs: isso é hacky\n        const panel: any = this.matSelect.panel.nativeElement;\n        const scrollTop: any = panel.scrollTop;\n\n        // Seta o foco\n        this.searchSelectInput.nativeElement.focus();\n\n        panel.scrollTop = scrollTop;\n    }\n\n    /**\n     * Redefine o valor de pesquisa atual\n     * @param focus se deve focar após a redefinição\n     */\n    public _reset(focus?: boolean): void {\n        this._formControl.setValue('');\n        if (focus) {\n            this._focus();\n        }\n    }\n\n    /**\n     * Inicializa a manipulação <mat-select [multiple]=\"true\">\n     * Nota: para melhorar este código, mat-select deve ser estendido para permitir desabilitar a redefinição da seleção durante a filtragem.\n     */\n    private initMultipleHandling(): void {\n        if (!this.matSelect.ngControl) {\n            if (this.matSelect.multiple) {\n                // nota: o acesso a matSelect.ngControl (em vez de matSelect.value / matSelect.valueChanges)\n                // é necessário para funcionar corretamente no modo de seleção múltipla.\n                console.error('o mat-select contendo itss-input-search deve ter uma diretiva ngModel ou formControl quando multiple=true');\n            }\n            return;\n        }\n        // Se <mat-select [multiple]=\"true\">\n        // armazenar valores previamente selecionados e restaurá-los quando forem desmarcados\n        // porque a opção não está disponível enquanto estamos filtrando\n        this.previousSelectedValues = this.matSelect.ngControl.value;\n\n        this.matSelect.ngControl.valueChanges\n            .pipe(takeUntil(this._onDestroy))\n            .subscribe((values: any): void => {\n                let restoreSelectedValues: boolean = false;\n\n                if (this.matSelect.multiple) {\n                    if ((this.alwaysRestoreSelectedOptionsMulti || (this._formControl.value && this._formControl.value.length))\n                        && this.previousSelectedValues && Array.isArray(this.previousSelectedValues)) {\n\n                        if (!values || !Array.isArray(values)) {\n                            values = [];\n                        }\n\n                        const optionValues: any[] = this.matSelect.options.map((option: MatOption): any => option.value);\n\n                        this.previousSelectedValues.forEach((previousValue: any): void => {\n                            if (!values.some((v: any): boolean => this.matSelect.compareWith(v, previousValue))\n                                && !optionValues.some((v: any): boolean => this.matSelect.compareWith(v, previousValue))) {\n                                // Se um valor que foi selecionado antes for desmarcado e não encontrado nas opções, ele foi desmarcado\n                                // devido à filtragem, então restauramos.\n                                values.push(previousValue);\n                                restoreSelectedValues = true;\n                            }\n                        });\n                    }\n                }\n                this.previousSelectedValues = values;\n\n                if (restoreSelectedValues) {\n                    this.matSelect._onChange(values);\n                }\n            });\n    }\n\n    /**\n     *  Defina a largura do innerSelectSearch para ajustar até mesmo as barras de rolagem personalizadas\n     *  E apoiar todos os sistemas de operação\n     */\n    public updateInputWidth(): void {\n        if (!this.innerSelectSearch || !this.innerSelectSearch.nativeElement) {\n            return;\n        }\n        let element: HTMLElement = this.innerSelectSearch.nativeElement;\n        let panelElement: HTMLElement;\n        while (element = element.parentElement) {\n            if (element.classList.contains('mat-select-panel')) {\n                panelElement = element;\n                break;\n            }\n        }\n        if (panelElement) {\n            this.innerSelectSearch.nativeElement.style.width = panelElement.clientWidth + 'px';\n        }\n    }\n\n    /**\n     * Determine o deslocamento para o comprimento que pode ser causado pelo matOption opcional usado como uma entrada de pesquisa.\n     */\n    private getOptionsLengthOffset(): number {\n        if (this.matOption) {\n            return 1;\n        } else {\n            return 0;\n        }\n    }\n\n    private unselectActiveDescendant(): void {\n        if (this.activeDescendant) {\n            this.activeDescendant.removeAttribute('aria-selected');\n        }\n        this.searchSelectInput.nativeElement.removeAttribute('aria-activedescendant');\n    }\n\n\n}\n"]}