@gipisistemas/ng-core 1.1.0 → 1.1.2

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

@@ -0,0 +1,547 @@
+var SelectSearchComponent_1;
+import { __decorate, __metadata, __param } 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
+ */
+let SelectSearchComponent = SelectSearchComponent_1 = class SelectSearchComponent {
+    constructor(matSelect, changeDetectorRef, _viewportRuler, matOption = null, matFormField = null, defaultOptions) {
+        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((_options) => _options
+            ? _options.changes.pipe(map((options) => options.toArray()), startWith(_options.toArray()))
+            : of(null)));
+        this.optionsLength$ = this.optionsList$.pipe(map((options) => 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(([value, optionsLength]) => this.noEntriesFoundLabel && value
+            && optionsLength === this.getOptionsLengthOffset()));
+        // Subject emitido quando o componente foi destruído
+        this._onDestroy = new Subject();
+        this.onTouched = (_) => { };
+        this.applyDefaultOptions(defaultOptions);
+    }
+    // Valor de pesquisa atual
+    get value() {
+        return this._formControl.value;
+    }
+    // Referência às opções MatSelect
+    set _options(_options) {
+        this._options$.next(_options);
+    }
+    get _options() {
+        return this._options$.getValue();
+    }
+    // Adiciona a classe mat-select-search-inside-mat-option se o itss-select-search estiver
+    // dentro do mat-option
+    get isInsideMatOption() {
+        return !!this.matOption;
+    }
+    set toggleAllCheckboxChecked(value) {
+        this._toggleAllCheckboxChecked = value;
+        this.toggleAll.emit(value);
+    }
+    get toggleAllCheckboxChecked() {
+        return this._toggleAllCheckboxChecked;
+    }
+    set toggleAllCheckboxIndeterminate(value) {
+        this._toggleAllCheckboxIndeterminate = value;
+        this.toggleAllIndeterminate.emit(value);
+    }
+    get toggleAllCheckboxIndeterminate() {
+        return this._toggleAllCheckboxIndeterminate;
+    }
+    applyDefaultOptions(defaultOptions) {
+        if (!defaultOptions) {
+            return;
+        }
+        for (const key of configurableDefaultOptions) {
+            if (defaultOptions.hasOwnProperty(key)) {
+                this[key] = defaultOptions[key];
+            }
+        }
+    }
+    ngOnInit() {
+        // 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((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(() => {
+            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.
+            let previousFirstOption = this._options.toArray()[this.getOptionsLengthOffset()];
+            return this._options.changes
+                .pipe(tap(() => {
+                // Evitar o erro "expression has been changed"
+                setTimeout(() => {
+                    // Converter a QueryList em uma matriz
+                    const options = this._options.toArray();
+                    // O verdadeiro primeiro item é compensado por 1
+                    const currentFirstOption = options[this.getOptionsLengthOffset()];
+                    const 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.
+                        const 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((option) => this.matSelect.compareWith(option, keyManager.activeItem))) {
+                            keyManager.setFirstItemActive();
+                        }
+                        // Aguarde as alterações na largura do painel
+                        setTimeout(() => {
+                            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((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(() => {
+            if (this.matSelect.panelOpen) {
+                this.updateInputWidth();
+            }
+        });
+        this.initMultipleHandling();
+        this.optionsList$.pipe(takeUntil(this._onDestroy)).subscribe(() => {
+            // Atualizar visualização quando as opções disponíveis mudarem
+            this.changeDetectorRef.markForCheck();
+        });
+    }
+    ngOnChanges(changes) {
+        if (this.searching) {
+            this._formControl.disable();
+        }
+        else {
+            this._formControl.enable();
+            this._focus();
+        }
+    }
+    ngOnDestroy() {
+        this._onDestroy.next();
+        this._onDestroy.complete();
+    }
+    _isToggleAllCheckboxVisible() {
+        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
+     */
+    _handleKeydown(event) {
+        // 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(() => 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.
+     */
+    _handleKeyup(event) {
+        if (event.keyCode === UP_ARROW || event.keyCode === DOWN_ARROW) {
+            const ariaActiveDescendantId = this.matSelect._getAriaActiveDescendant();
+            const index = this._options.toArray().findIndex((item) => item.id === ariaActiveDescendantId);
+            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);
+            }
+        }
+    }
+    writeValue(value) {
+        this._lastExternalInputValue = value;
+        this._formControl.setValue(value);
+        this.changeDetectorRef.markForCheck();
+    }
+    onBlur() {
+        this.unselectActiveDescendant();
+        this.onTouched();
+    }
+    registerOnChange(fn) {
+        this._formControl.valueChanges.pipe(filter((value) => value !== this._lastExternalInputValue), tap(() => this._lastExternalInputValue = undefined), takeUntil(this._onDestroy)).subscribe(fn);
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Focaliza o campo de entrada de pesquisa
+     */
+    _focus() {
+        if (!this.searchSelectInput || !this.matSelect.panel) {
+            return;
+        }
+        // salve e restaure o scrollTop do painel, pois será redefinido por focus ()
+        // obs: isso é hacky
+        const panel = this.matSelect.panel.nativeElement;
+        const 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
+     */
+    _reset(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.
+     */
+    initMultipleHandling() {
+        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((values) => {
+            let 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 = [];
+                    }
+                    const optionValues = this.matSelect.options.map((option) => option.value);
+                    this.previousSelectedValues.forEach((previousValue) => {
+                        if (!values.some((v) => this.matSelect.compareWith(v, previousValue))
+                            && !optionValues.some((v) => 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
+     */
+    updateInputWidth() {
+        if (!this.innerSelectSearch || !this.innerSelectSearch.nativeElement) {
+            return;
+        }
+        let element = this.innerSelectSearch.nativeElement;
+        let 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.
+     */
+    getOptionsLengthOffset() {
+        if (this.matOption) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    unselectActiveDescendant() {
+        if (this.activeDescendant) {
+            this.activeDescendant.removeAttribute('aria-selected');
+        }
+        this.searchSelectInput.nativeElement.removeAttribute('aria-activedescendant');
+    }
+};
+SelectSearchComponent.ctorParameters = () => [
+    { 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(() => 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);
+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":";;AACA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAChH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3P,OAAO,EAAwB,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACtF,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,eAAe,EAAc,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC/E,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAEhG,OAAO,EAAE,kCAAkC,EAA2B,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAC7H,OAAO,EAAE,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAE9E;;;GAGG;AAcH,IAAa,qBAAqB,6BAAlC,MAAa,qBAAqB;IAsB9B,YAC8B,SAAoB,EACvC,iBAAoC,EACnC,cAA6B,EACC,YAAuB,IAAI,EACxB,eAA6B,IAAI,EAClB,cAAwC;QALtE,cAAS,GAAT,SAAS,CAAW;QACvC,sBAAiB,GAAjB,iBAAiB,CAAmB;QACnC,mBAAc,GAAd,cAAc,CAAe;QACC,cAAS,GAAT,SAAS,CAAkB;QACxB,iBAAY,GAAZ,YAAY,CAAqB;QAM9E,4CAA4C;QACnC,qBAAgB,GAAW,cAAc,CAAC;QAEnD,uCAAuC;QAC9B,SAAI,GAAW,MAAM,CAAC;QAE/B,sDAAsD;QAC7C,cAAS,GAAW,OAAO,CAAC;QAKrC,sHAAsH;QAC7G,wBAAmB,GAAW,6BAA6B,CAAC;QAErE;;;WAGG;QACM,qBAAgB,GAAY,IAAI,CAAC;QAE1C,uDAAuD;QAC9C,cAAS,GAAY,KAAK,CAAC;QAEpC,8CAA8C;QACrC,wBAAmB,GAAY,KAAK,CAAC;QAE9C,2CAA2C;QAClC,+BAA0B,GAAY,KAAK,CAAC;QAErD;;;WAGG;QACM,iCAA4B,GAAY,KAAK,CAAC;QAEvD,uHAAuH;QAC9G,0CAAqC,GAAY,KAAK,CAAC;QAEhE,+DAA+D;QACtD,cAAS,GAAW,mBAAmB,CAAC;QAEjD,mFAAmF;QAC1E,0BAAqB,GAAY,KAAK,CAAC;QAEhD,iDAAiD;QACzC,8BAAyB,GAAY,KAAK,CAAC;QASnD,yDAAyD;QACjD,oCAA+B,GAAY,KAAK,CAAC;QASzD,qFAAqF;QAC5E,oCAA+B,GAAW,EAAE,CAAC;QAEtD,+EAA+E;QACtE,qCAAgC,GAA8D,OAAO,CAAC;QAE/G,iEAAiE;QACxD,0BAAqB,GAAY,KAAK,CAAC;QAEhD;;;WAGG;QACM,sCAAiC,GAAY,KAAK,CAAC;QAE5D,yFAAyF;QAC/E,cAAS,GAA0B,IAAI,YAAY,EAAW,CAAC;QAC/D,2BAAsB,GAA0B,IAAI,YAAY,EAAW,CAAC;QAc/E,cAAS,GAA0C,IAAI,eAAe,CAAuB,IAAI,CAAC,CAAC;QAElG,iBAAY,GAA4B,IAAI,CAAC,SAAS,CAAC,IAAI,CAC/D,SAAS,CAAC,CAAC,QAA8B,EAAmB,EAAE,CAAC,QAAQ;YACnE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CACnB,GAAG,CAAC,CAAC,OAAY,EAAO,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,EAC7C,SAAS,CAAc,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAE;YAChD,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CACb,CACJ,CAAC;QAEM,mBAAc,GAAuB,IAAI,CAAC,YAAY,CAAC,IAAI,CAC/D,GAAG,CAAC,CAAC,OAAoB,EAAU,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CACtE,CAAC;QAKK,iBAAY,GAAgB,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;QAEvD,sDAAsD;QAC/C,yBAAoB,GAAwB,aAAa,CAAC;YAC7D,IAAI,CAAC,YAAY,CAAC,YAAY;YAC9B,IAAI,CAAC,cAAc;SACtB,CAAC,CAAC,IAAI,CACH,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,aAAa,CAAgB,EAAW,EAAE,CAAC,IAAI,CAAC,mBAAmB,IAAI,KAAK;eAClF,aAAa,KAAK,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAC1D,CAAC;QAEF,oDAAoD;QAC5C,eAAU,GAAkB,IAAI,OAAO,EAAQ,CAAC;QA4JxD,cAAS,GAAa,CAAC,CAAM,EAAQ,EAAE,GAAG,CAAC,CAAC;QA7RxC,IAAI,CAAC,mBAAmB,CAAC,cAAc,CAAC,CAAC;IAC7C,CAAC;IA7BD,0BAA0B;IAC1B,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACnC,CAAC;IAED,iCAAiC;IACjC,IAAW,QAAQ,CAAC,QAA8B;QAC9C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClC,CAAC;IACD,IAAW,QAAQ;QACf,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACrC,CAAC;IAED,wFAAwF;IACxF,uBAAuB;IAEvB,IAAI,iBAAiB;QACjB,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;IAC5B,CAAC;IA4DQ,IAAI,wBAAwB,CAAC,KAAc;QAChD,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;QACvC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,IAAI,wBAAwB;QACxB,OAAO,IAAI,CAAC,yBAAyB,CAAC;IAC1C,CAAC;IAIQ,IAAI,8BAA8B,CAAC,KAAc;QACtD,IAAI,CAAC,+BAA+B,GAAG,KAAK,CAAC;QAC7C,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IACD,IAAI,8BAA8B;QAC9B,OAAO,IAAI,CAAC,+BAA+B,CAAC;IAChD,CAAC;IAoEO,mBAAmB,CAAC,cAAuC;QAC/D,IAAI,CAAC,cAAc,EAAE;YACjB,OAAO;SACV;QAED,KAAK,MAAM,GAAG,IAAI,0BAA0B,EAAE;YAC1C,IAAI,cAAc,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;gBACnC,IAAI,CAAC,GAAG,CAAS,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;aAC5C;SACJ;IACL,CAAC;IAED,QAAQ;QACJ,iGAAiG;QACjG,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;YAC7E,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC,YAAY,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;SACxE;aAAM;YACH,OAAO,CAAC,KAAK,CAAC,0EAA0E,CAAC,CAAC;SAC7F;QAED,0DAA0D;QAC1D,IAAI,CAAC,SAAS,CAAC,YAAY;aACtB,IAAI,CACD,KAAK,CAAC,CAAC,CAAC,EACR,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC7B;aACA,SAAS,CAAC,CAAC,MAAe,EAAQ,EAAE;YACjC,IAAI,MAAM,EAAE;gBACR,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAExB,qCAAqC;gBACrC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;oBAC3B,IAAI,CAAC,MAAM,EAAE,CAAC;iBACjB;aACJ;iBAAM;gBACH,qBAAqB;gBACrB,IAAI,IAAI,CAAC,gBAAgB,EAAE;oBACvB,IAAI,CAAC,MAAM,EAAE,CAAC;iBACjB;aACJ;QACL,CAAC,CAAC,CAAC;QAEP,yDAAyD;QACzD,IAAI,CAAC,SAAS,CAAC,YAAY;aACtB,IAAI,CACD,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,GAAoB,EAAE;YAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YAEvC,sEAAsE;YACtE,8FAA8F;YAC9F,6FAA6F;YAC7F,+FAA+F;YAC/F,+FAA+F;YAC/F,mEAAmE;YACnE,IAAI,mBAAmB,GAAc,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;YAE5F,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO;iBACvB,IAAI,CACD,GAAG,CAAC,GAAS,EAAE;gBACX,8CAA8C;gBAC9C,UAAU,CAAC,GAAS,EAAE;oBAClB,sCAAsC;oBACtC,MAAM,OAAO,GAAgB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;oBAErD,gDAAgD;oBAChD,MAAM,kBAAkB,GAAc,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC;oBAE7E,MAAM,UAAU,GAA0C,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;oBACrF,IAAI,UAAU,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;wBAExC,mDAAmD;wBAEnD,2EAA2E;wBAC3E,MAAM,oBAAoB,GAAY,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,CAAC;wBAE3G,4CAA4C;wBAC5C,+DAA+D;wBAC/D,IAAI,oBAAoB;+BACjB,CAAC,UAAU,CAAC,UAAU;+BACtB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAiB,EAAW,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE;4BAC7G,UAAU,CAAC,kBAAkB,EAAE,CAAC;yBACnC;wBAED,6CAA6C;wBAC7C,UAAU,CAAC,GAAS,EAAE;4BAClB,IAAI,CAAC,gBAAgB,EAAE,CAAC;wBAC5B,CAAC,CAAC,CAAC;qBACN;oBAED,4BAA4B;oBAC5B,mBAAmB,GAAG,kBAAkB,CAAC;gBAC7C,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CACL,CAAC;QACV,CAAC,CAAC,CACL;aACA,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,EAAE,CAAC;QAEjB,mGAAmG;QACnG,oBAAoB;QACpB,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAC1B,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC7B,CAAC,SAAS,CAAC,CAAC,kBAA2B,EAAQ,EAAE;YAC9C,6DAA6D;YAC7D,IAAI,IAAI,CAAC,SAAS,EAAE;gBAChB,IAAI,kBAAkB,EAAE;oBACpB,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;iBACxF;qBAAM;oBACH,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,oCAAoC,CAAC,CAAC;iBAC3F;aACJ;QACL,CAAC,CAAC,CAAC;QAEH,0EAA0E;QAC1E,2DAA2D;QAC3D,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE;aACvB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,CAAC,GAAS,EAAE;YAClB,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;gBAC1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;aAC3B;QACL,CAAC,CAAC,CAAC;QAEP,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE5B,IAAI,CAAC,YAAY,CAAC,IAAI,CAClB,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC7B,CAAC,SAAS,CAAC,GAAS,EAAE;YACnB,8DAA8D;YAC9D,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;QAC1C,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;SAC/B;aAAM;YACH,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,MAAM,EAAE,CAAC;SACjB;IACL,CAAC;IAED,WAAW;QACP,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAID,2BAA2B;QACvB,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,IAAI,CAAC,qBAAqB,CAAC;IACjE,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAoB;QAC/B,2FAA2F;QAC3F,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC;YACrC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;YAC1C,CAAC,KAAK,CAAC,OAAO,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC;YAChD,CAAC,KAAK,CAAC,OAAO,KAAK,KAAK,CAAC;eACtB,CAAC,IAAI,CAAC,4BAA4B,IAAI,CAAC,KAAK,CAAC,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,KAAK,GAAG,CAAC,CAAC,EAC7F;YACE,KAAK,CAAC,eAAe,EAAE,CAAC;SAC3B;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,KAAK,KAAK,EAAE;YACjE,gFAAgF;YAChF,UAAU,CAAC,GAAS,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;SACzC;QAED,qIAAqI;QACrI,IAAI,IAAI,CAAC,0BAA0B,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK,EAAE;YACpF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAClB,KAAK,CAAC,eAAe,EAAE,CAAC;SAC3B;IACL,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,KAAoB;QAC7B,IAAI,KAAK,CAAC,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,KAAK,UAAU,EAAE;YAC5D,MAAM,sBAAsB,GAAW,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,CAAC;YACjF,MAAM,KAAK,GAAW,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,IAAe,EAAW,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,sBAAsB,CAAC,CAAC;YAC1H,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;gBACd,IAAI,CAAC,wBAAwB,EAAE,CAAC;gBAChC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,eAAe,EAAE,CAAC;gBACzE,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;gBAC5D,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,YAAY,CAAC,uBAAuB,EAAE,sBAAsB,CAAC,CAAC;aACtG;SACJ;IACL,CAAC;IAED,UAAU,CAAC,KAAa;QACpB,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAC;QACrC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;IAC1C,CAAC;IAED,MAAM;QACF,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;IAED,gBAAgB,CAAC,EAA2B;QACxC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAC/B,MAAM,CAAC,CAAC,KAAU,EAAW,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,uBAAuB,CAAC,EACvE,GAAG,CAAC,GAAQ,EAAE,CAAC,IAAI,CAAC,uBAAuB,GAAG,SAAS,CAAC,EACxD,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC7B,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACpB,CAAC;IAED,iBAAiB,CAAC,EAAY;QAC1B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,MAAM;QACT,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;YAClD,OAAO;SACV;QACD,4EAA4E;QAC5E,oBAAoB;QACpB,MAAM,KAAK,GAAQ,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC;QACtD,MAAM,SAAS,GAAQ,KAAK,CAAC,SAAS,CAAC;QAEvC,cAAc;QACd,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAE7C,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;IAChC,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,KAAe;QACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC/B,IAAI,KAAK,EAAE;YACP,IAAI,CAAC,MAAM,EAAE,CAAC;SACjB;IACL,CAAC;IAED;;;OAGG;IACK,oBAAoB;QACxB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;YAC3B,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBACzB,4FAA4F;gBAC5F,wEAAwE;gBACxE,OAAO,CAAC,KAAK,CAAC,2GAA2G,CAAC,CAAC;aAC9H;YACD,OAAO;SACV;QACD,oCAAoC;QACpC,qFAAqF;QACrF,gEAAgE;QAChE,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC;QAE7D,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY;aAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAChC,SAAS,CAAC,CAAC,MAAW,EAAQ,EAAE;YAC7B,IAAI,qBAAqB,GAAY,KAAK,CAAC;YAE3C,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBACzB,IAAI,CAAC,IAAI,CAAC,iCAAiC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;uBACpG,IAAI,CAAC,sBAAsB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,EAAE;oBAE9E,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;wBACnC,MAAM,GAAG,EAAE,CAAC;qBACf;oBAED,MAAM,YAAY,GAAU,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAiB,EAAO,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAEjG,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC,aAAkB,EAAQ,EAAE;wBAC7D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAM,EAAW,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;+BAC5E,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAM,EAAW,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE;4BAC1F,uGAAuG;4BACvG,yCAAyC;4BACzC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;4BAC3B,qBAAqB,GAAG,IAAI,CAAC;yBAChC;oBACL,CAAC,CAAC,CAAC;iBACN;aACJ;YACD,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC;YAErC,IAAI,qBAAqB,EAAE;gBACvB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;aACpC;QACL,CAAC,CAAC,CAAC;IACX,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACnB,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE;YAClE,OAAO;SACV;QACD,IAAI,OAAO,GAAgB,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC;QAChE,IAAI,YAAyB,CAAC;QAC9B,OAAO,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE;YACpC,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE;gBAChD,YAAY,GAAG,OAAO,CAAC;gBACvB,MAAM;aACT;SACJ;QACD,IAAI,YAAY,EAAE;YACd,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,GAAG,YAAY,CAAC,WAAW,GAAG,IAAI,CAAC;SACtF;IACL,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC1B,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,OAAO,CAAC,CAAC;SACZ;aAAM;YACH,OAAO,CAAC,CAAC;SACZ;IACL,CAAC;IAEO,wBAAwB;QAC5B,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACvB,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;SAC1D;QACD,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,eAAe,CAAC,uBAAuB,CAAC,CAAC;IAClF,CAAC;CAGJ,CAAA;;YAve4C,SAAS,uBAA7C,MAAM,SAAC,SAAS;YACS,iBAAiB;YACnB,aAAa;YACY,SAAS,uBAAzD,QAAQ,YAAI,MAAM,SAAC,SAAS;YAC0B,YAAY,uBAAlE,QAAQ,YAAI,MAAM,SAAC,YAAY;4CAC/B,QAAQ,YAAI,MAAM,SAAC,kCAAkC;;AAV1D;IADC,WAAW,CAAC,2CAA2C,CAAC;;;8DAGxD;AAcQ;IAAR,KAAK,EAAE;;+DAA2C;AAG1C;IAAR,KAAK,EAAE;;mDAAuB;AAGtB;IAAR,KAAK,EAAE;;wDAA6B;AAG5B;IAAR,KAAK,EAAE;;2DAAuB;AAGtB;IAAR,KAAK,EAAE;;kEAA6D;AAM5D;IAAR,KAAK,EAAE;;+DAAkC;AAGjC;IAAR,KAAK,EAAE;;wDAA4B;AAG3B;IAAR,KAAK,EAAE;;kEAAsC;AAGrC;IAAR,KAAK,EAAE;;yEAA6C;AAM5C;IAAR,KAAK,EAAE;;2EAA+C;AAG9C;IAAR,KAAK,EAAE;;oFAAwD;AAGvD;IAAR,KAAK,EAAE;;wDAAyC;AAGxC;IAAR,KAAK,EAAE;;oEAAwC;AAIvC;IAAR,KAAK,EAAE;;;qEAGP;AAOQ;IAAR,KAAK,EAAE;;;2EAGP;AAMQ;IAAR,KAAK,EAAE;;8EAA8C;AAG7C;IAAR,KAAK,EAAE;;+EAAuG;AAGtG;IAAR,KAAK,EAAE;;oEAAwC;AAMvC;IAAR,KAAK,EAAE;;gFAAoD;AAGlD;IAAT,MAAM,EAAE;8BAAY,YAAY;wDAAwC;AAC/D;IAAT,MAAM,EAAE;8BAAyB,YAAY;qEAAwC;AAGlB;IAAnE,SAAS,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;8BAAoB,UAAU;gEAAC;AAG9B;IAAnE,SAAS,CAAC,mBAAmB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;8BAAoB,UAAU;gEAAC;AAGrC;IAA5D,YAAY,CAAC,0BAA0B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;8BAAY,0BAA0B;wDAAC;AAGnC;IAA/D,YAAY,CAAC,6BAA6B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;8BAAiB,6BAA6B;6DAAC;AA/HrG,qBAAqB;IAbjC,SAAS,CAAC;QACP,QAAQ,EAAE,mBAAmB;QAC7B,6zFAA6C;QAE7C,SAAS,EAAE;YACP;gBACI,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,CAAC,GAAiC,EAAE,CAAC,uBAAqB,CAAC;gBAClF,KAAK,EAAE,IAAI;aACd;SACJ;QACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;;KAClD,CAAC;IAwBO,WAAA,MAAM,CAAC,SAAS,CAAC,CAAA;IAGjB,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,SAAS,CAAC,CAAA;IAC7B,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,YAAY,CAAC,CAAA;IAChC,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,kCAAkC,CAAC,CAAA;qCALlB,SAAS;QACpB,iBAAiB;QACnB,aAAa;QACY,SAAS;QACH,YAAY;GA3B9D,qBAAqB,CA8fjC;SA9fY,qBAAqB","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"]}