@gipisistemas/ng-core 1.0.67 → 1.0.68

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

@@ -0,0 +1,397 @@
+import { __decorate, __metadata, __param, __read } 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, ElementRef, HostBinding, Inject, Input, OnChanges, OnDestroy, OnInit, Optional, 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';
+var GIPIInputSearchComponent = /** @class */ (function () {
+    function GIPIInputSearchComponent(matSelect, changeDetectorRef, _viewportRuler, matOption, matFormField) {
+        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;
+        // Referência às opções MatSelect
+        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 value && optionsLength === _this.getOptionsLengthOffset();
+        }));
+        // Subject emitido quando o componente foi destruído
+        this._onDestroy = new Subject();
+        this.placeholderLabel = 'Pesquisar';
+        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;
+        // Mostrar/ocultar o botão limpar pesquisa da entrada de pesquisa
+        this.hideClearSearchButton = false;
+        this.onTouched = function (_) { };
+    }
+    GIPIInputSearchComponent_1 = GIPIInputSearchComponent;
+    Object.defineProperty(GIPIInputSearchComponent.prototype, "value", {
+        // Valor de pesquisa atual
+        get: function () {
+            return this._formControl.value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSearchComponent.prototype, "_options", {
+        get: function () {
+            return this._options$.getValue();
+        },
+        set: function (_options) {
+            this._options$.next(_options);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputSearchComponent.prototype, "isInsideMatOption", {
+        // Adiciona a classe mat-select-search-inside-mat-option se o itss-input-search estiver
+        // dentro do mat-option
+        get: function () {
+            return !!this.matOption;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIInputSearchComponent.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('<gipi-select-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.optionsList$.pipe(takeUntil(this._onDestroy)).subscribe(function () {
+            // Atualizar visualização quando as opções disponíveis mudarem
+            _this.changeDetectorRef.markForCheck();
+        });
+    };
+    GIPIInputSearchComponent.prototype.ngOnChanges = function (changes) {
+        if (this.searching) {
+            this._formControl.disable();
+        }
+        else {
+            this._formControl.enable();
+            this._focus();
+        }
+    };
+    GIPIInputSearchComponent.prototype.ngOnDestroy = function () {
+        this._onDestroy.next();
+        this._onDestroy.complete();
+    };
+    GIPIInputSearchComponent.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);
+    };
+    GIPIInputSearchComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    GIPIInputSearchComponent.prototype.writeValue = function (value) {
+        this._lastExternalInputValue = value;
+        this._formControl.setValue(value);
+        this.changeDetectorRef.markForCheck();
+    };
+    /**
+     * 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
+     */
+    GIPIInputSearchComponent.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.
+     */
+    GIPIInputSearchComponent.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);
+            }
+        }
+    };
+    GIPIInputSearchComponent.prototype.onBlur = function () {
+        this.unselectActiveDescendant();
+        this.onTouched();
+    };
+    /**
+     * Focaliza o campo de entrada de pesquisa
+     */
+    GIPIInputSearchComponent.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
+     */
+    GIPIInputSearchComponent.prototype._reset = function (focus) {
+        this._formControl.setValue('');
+        if (focus) {
+            this._focus();
+        }
+    };
+    /**
+     *  Defina a largura do innerSelectSearch para ajustar até mesmo as barras de rolagem personalizadas
+     *  E apoiar todos os sistemas de operação
+     */
+    GIPIInputSearchComponent.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.
+     */
+    GIPIInputSearchComponent.prototype.getOptionsLengthOffset = function () {
+        if (this.matOption) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    };
+    GIPIInputSearchComponent.prototype.unselectActiveDescendant = function () {
+        if (this.activeDescendant) {
+            this.activeDescendant.removeAttribute('aria-selected');
+        }
+        this.searchSelectInput.nativeElement.removeAttribute('aria-activedescendant');
+    };
+    var GIPIInputSearchComponent_1;
+    GIPIInputSearchComponent.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,] }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputSearchComponent.prototype, "placeholderLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "clearSearchInput", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "searching", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "disableInitialFocus", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "enableClearOnEscapePressed", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "preventHomeEndKeyPropagation", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "disableScrollToActiveOnOptionsChanged", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputSearchComponent.prototype, "hideClearSearchButton", void 0);
+    __decorate([
+        ViewChild('searchSelectInput', { read: ElementRef, static: true }),
+        __metadata("design:type", ElementRef)
+    ], GIPIInputSearchComponent.prototype, "searchSelectInput", void 0);
+    __decorate([
+        ViewChild('innerSelectSearch', { read: ElementRef, static: true }),
+        __metadata("design:type", ElementRef)
+    ], GIPIInputSearchComponent.prototype, "innerSelectSearch", void 0);
+    __decorate([
+        HostBinding('class.mat-select-search-inside-mat-option'),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [])
+    ], GIPIInputSearchComponent.prototype, "isInsideMatOption", null);
+    GIPIInputSearchComponent = GIPIInputSearchComponent_1 = __decorate([
+        Component({
+            selector: "gipi-input-search",
+            exportAs: 'gipiInputSearch',
+            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\n    <input class=\"mat-select-search-input mat-input-element\"\n           aria-label=\"Pesquisa suspensa\"\n           autocomplete=\"off\"\n           type=\"text\"\n           #searchSelectInput\n           [placeholder]=\"placeholderLabel\"\n           [formControl]=\"_formControl\"\n           (keydown)=\"_handleKeydown($event)\"\n           (keyup)=\"_handleKeyup($event)\"\n           (blur)=\"onBlur()\">\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            class=\"mat-select-search-clear\"\n            aria-label=\"Limpar\"\n            mat-icon-button\n            (click)=\"_reset(true)\">\n        <mat-icon> close </mat-icon>\n    </button>\n\n    <mat-divider> </mat-divider>\n</div>\n\n<div *ngIf=\"(_showNoEntriesFound$ | async) && !searching\"\n     class=\"mat-select-search-no-entries-found\">\n    <mat-icon>sentiment_very_dissatisfied</mat-icon>\n    Nenhum registro foi encontrado\n</div>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPIInputSearchComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-input-search',
+            },
+            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-select-search-no-entries-found{height:6em}.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:#e0313e;color:#e0313e;box-shadow:9999px 0 0 -5px;-webkit-animation:1.5s linear .25s infinite dot-pulse;animation:1.5s linear .25s infinite dot-pulse}.dot-pulse::after,.dot-pulse::before{content:\"\";display:inline-block;position:absolute;top:0;width:5px;height:5px;border-radius:50%;background-color:#e0313e;color:#e0313e}.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)),
+        __metadata("design:paramtypes", [MatSelect,
+            ChangeDetectorRef,
+            ViewportRuler,
+            MatOption,
+            MatFormField])
+    ], GIPIInputSearchComponent);
+    return GIPIInputSearchComponent;
+}());
+export { GIPIInputSearchComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-search.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/input-select-paged/input-search/input-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, ElementRef, HostBinding, Inject, Input, OnChanges, OnDestroy, OnInit, Optional, 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\n@Component({\n    selector: `gipi-input-search`,\n    exportAs: 'gipiInputSearch',\n    templateUrl: './input-search.component.html',\n    styleUrls: ['./input-search.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof GIPIInputSearchComponent => GIPIInputSearchComponent),\n            multi: true\n        }\n    ],\n    host: {\n        'class': 'gipi-input-search',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class GIPIInputSearchComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {\n\n    // Valor de pesquisa atual\n    get value(): string {\n        return this._formControl.value;\n    }\n\n    private _lastExternalInputValue: string;\n\n    // Referência às opções MatSelect\n    public _options$: BehaviorSubject<QueryList<MatOption>> = new BehaviorSubject<QueryList<MatOption>>(null);\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    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    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 => value && 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    @Input() placeholderLabel: string = 'Pesquisar';\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    // Mostrar/ocultar o botão limpar pesquisa da entrada de pesquisa\n    @Input() hideClearSearchButton: boolean = false;\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    // Adiciona a classe mat-select-search-inside-mat-option se o itss-input-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    ) { }\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('<gipi-select-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.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    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    writeValue(value: string): void {\n        this._lastExternalInputValue = value;\n        this._formControl.setValue(value);\n        this.changeDetectorRef.markForCheck();\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    onBlur(): void {\n        this.unselectActiveDescendant();\n        this.onTouched();\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     *  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"]}