@govbr-ds/webcomponents 2.1.0 → 2.1.1

package/dist/collection/components/select/select-list/select-list.js

@@ -0,0 +1,1147 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h } from "@stencil/core";
+import { createRafBatcher } from "../../../shared/utils/raf-batcher";
+/**
+ * ## Design System
+ *
+ * Para a documentação completa de design, incluindo diretrizes de uso, acessibilidade e exemplos visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/select?tab=designer).
+ *
+ * @category Formulários
+ * @status stable
+ * @part list - Contêiner visual da lista virtualizada.
+ * @slot loading - Indicador exibido enquanto resultados remotos são carregados.
+ * @part loading - Área do indicador de carregamento.
+ */
+export class SelectList {
+    constructor() {
+        /**
+         * Coleção de opções exibidas pela lista.
+         *
+         * @type {SelectOptionData[]}
+         * @default []
+         */
+        this.options = [];
+        /**
+         * Termo usado para filtrar opções por rótulo ou valor.
+         *
+         * @default ''
+         */
+        this.searchTerm = '';
+        /** Indica que os resultados remotos estão sendo carregados.
+         * @default false
+         */
+        this.loading = false;
+        /**
+         * Define quantas opções permanecem visíveis na viewport da lista.
+         *
+         * @default 6
+         */
+        this.visibleItems = 6;
+        /**
+         * Informa a altura base usada no cálculo de posicionamento das opções.
+         *
+         * @default 56
+         */
+        this.itemHeight = 56;
+        /**
+         * Define quantas opções extras são renderizadas fora da viewport quando o virtual scroll está ativo.
+         *
+         * @default 0
+         */
+        this.overscan = 0;
+        /**
+         * Rótulo apresentado para a ação de selecionar todos no modo múltiplo.
+         *
+         * @default 'Selecionar todos'
+         */
+        this.selectAllLabel = SelectList.SELECT_ALL_LABEL;
+        /**
+         * Rótulo apresentado quando todas as opções já estão selecionadas no modo múltiplo.
+         *
+         * @default 'Desselecionar todos'
+         */
+        this.unselectAllLabel = SelectList.DESELECT_ALL_LABEL;
+        /**
+         * Índice da opção atualmente ativa para navegação por teclado.
+         *
+         * @default -1
+         * @remarks
+         * Esse valor é usado para refletir visualmente o foco lógico da lista.
+         */
+        this.activeOptionIndex = -1;
+        this.isOpen = false;
+        this.isMultiple = false;
+        this.scrollTop = 0;
+        this.measuredItemHeight = null;
+        this.measurementFrame = null;
+        this.filteredOptionsCache = null;
+        this.filteredOptionsCacheKey = '';
+        this.scrollBatch = createRafBatcher((scrollTop) => {
+            if (this.scrollTop !== scrollTop)
+                this.scrollTop = scrollTop;
+        });
+        /**
+         * Aguarda o próximo frame para que medições e queries reflitam o DOM recém-renderizado.
+         *
+         * @returns Uma promise resolvida no próximo `requestAnimationFrame`.
+         */
+        this.waitForNextFrame = async () => {
+            await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+        };
+        this.handleScroll = (event) => {
+            const target = event.target;
+            this.scrollBatch.schedule(target?.scrollTop ?? 0);
+        };
+    }
+    disconnectedCallback() {
+        this.scrollBatch.cancel();
+        if (this.measurementFrame !== null) {
+            cancelAnimationFrame(this.measurementFrame);
+            this.measurementFrame = null;
+        }
+    }
+    handleSearchTermChange() {
+        this.scrollTop = 0;
+        if (this.listElement) {
+            this.listElement.scrollTop = 0;
+        }
+        this.scheduleMeasureItemHeight();
+    }
+    handleSelectAllLabelChange() {
+        if (!this.isMultiple)
+            return;
+        this.options = this.syncSelectAllOption(this.options);
+    }
+    handleOptionStateChange(event) {
+        const detail = event.detail;
+        if (!detail?.value)
+            return;
+        if (this.isMultiple)
+            return this.applyMultipleOption(detail);
+        if (detail.selected)
+            return this.applySingleSelect(detail);
+        return this.clearSingleSelection();
+    }
+    /**
+     * Abre a lista e agenda a medição das opções quando necessário.
+     *
+     * @returns Uma promise concluída após a atualização do estado.
+     */
+    async open() {
+        this.isOpen = true;
+        this.scheduleMeasureItemHeight();
+    }
+    /**
+     * Fecha a lista de opções.
+     *
+     * @returns Uma promise concluída após a atualização do estado.
+     */
+    async close() {
+        this.isOpen = false;
+    }
+    /**
+     * Substitui todas as opções renderizadas pela lista.
+     *
+     * @param options Nova coleção de opções normalizadas.
+     * @returns Uma promise concluída após a atualização da lista.
+     */
+    async setOptions(options) {
+        if (!options || options.length === 0) {
+            this.options = [];
+            this.scrollTop = 0;
+            this.measuredItemHeight = null;
+            if (this.listElement) {
+                this.listElement.scrollTop = 0;
+            }
+            return;
+        }
+        const map = new Map();
+        let hasDuplicates = false;
+        options.forEach((opt) => {
+            if (map.has(opt.value)) {
+                hasDuplicates = true;
+            }
+            map.set(opt.value, opt);
+        });
+        if (hasDuplicates) {
+            console.warn('[br-select-list] Foram encontrados valores duplicados em `setOptions`. Apenas a ultima ocorrencia de cada `value` sera mantida.');
+        }
+        const nextOptions = Array.from(map.values());
+        this.options = this.normalizeOptionsForMode(nextOptions, this.isMultiple);
+        this.scheduleMeasureItemHeight();
+        requestAnimationFrame(() => this.clampScrollPosition());
+    }
+    /**
+     * Adiciona ou atualiza uma única opção na coleção atual.
+     *
+     * @param option Opção que deve ser persistida na lista.
+     * @returns Uma promise concluída após a atualização da coleção.
+     */
+    async setOption(option) {
+        const index = this.options.findIndex((opt) => opt.value === option.value);
+        let nextOptions;
+        if (index !== -1) {
+            nextOptions = this.options.map((opt) => (opt.value === option.value ? option : opt));
+        }
+        else {
+            nextOptions = [...this.options, option];
+        }
+        this.options = this.normalizeOptionsForMode(nextOptions, this.isMultiple);
+        requestAnimationFrame(() => this.clampScrollPosition());
+    }
+    /**
+     * Atualiza o termo de busca e reinicia a janela virtual no topo.
+     *
+     * @param term Termo que deve filtrar a coleção. String vazia restaura todas as opções.
+     */
+    async setSearchTerm(term) {
+        const nextTerm = term ?? '';
+        if (nextTerm === this.searchTerm)
+            return;
+        this.searchTerm = nextTerm;
+        this.scrollTop = 0;
+        if (this.listElement) {
+            this.listElement.scrollTop = 0;
+        }
+        this.scheduleMeasureItemHeight();
+    }
+    /**
+     * Alterna a lista entre modo simples e múltiplo.
+     *
+     * @param isMultiple Define se a lista deve operar em seleção múltipla.
+     * @returns Uma promise concluída após a atualização do modo.
+     */
+    async setMultiple(isMultiple) {
+        this.isMultiple = isMultiple;
+        this.options = this.normalizeOptionsForMode(this.options, isMultiple);
+        this.scheduleMeasureItemHeight();
+    }
+    /**
+     * Retorna uma cópia das opções atualmente controladas pela lista.
+     *
+     * @returns As opções renderizadas no estado atual.
+     */
+    async getOptions() {
+        return this.options.map((option) => ({ ...option }));
+    }
+    /**
+     * Posiciona uma opção no topo da viewport virtual, respeitando o limite final da lista.
+     *
+     * @param index Índice lógico da opção alvo.
+     * @returns `true` quando o índice pertence à coleção filtrada atual.
+     */
+    async scrollOptionToTop(index) {
+        const filteredOptions = this.getFilteredOptions();
+        if (index < 0 || index >= filteredOptions.length || !this.listElement)
+            return false;
+        const rowHeight = this.getRowHeight();
+        const viewportHeight = this.getViewportHeight();
+        const maxScrollTop = Math.max(0, filteredOptions.length * rowHeight - viewportHeight);
+        const nextScrollTop = Math.min(index * rowHeight, maxScrollTop);
+        /*
+         * Atualiza primeiro o estado que define a janela virtual. Dessa forma,
+         * os itens do novo intervalo são renderizados antes de o viewport nativo
+         * avançar, evitando uma linha vazia durante o reposicionamento.
+         */
+        this.scrollTop = nextScrollTop;
+        await this.waitForNextFrame();
+        this.listElement.scrollTop = nextScrollTop;
+        await this.waitForNextFrame();
+        return true;
+    }
+    /**
+     * Posiciona no topo a primeira opção selecionada na ordem visual da lista.
+     * A opção auxiliar de selecionar tudo não participa dessa escolha.
+     *
+     * @returns `true` quando existe uma opção selecionada para posicionar.
+     */
+    async scrollFirstSelectedOptionToTop() {
+        const filteredOptions = this.getFilteredOptions();
+        const selectedIndex = filteredOptions.findIndex((option) => !this.isSelectAllOption(option) && Boolean(option.selected));
+        if (selectedIndex < 0)
+            return false;
+        return this.scrollOptionToTop(selectedIndex);
+    }
+    /**
+     * Garante visibilidade e foco para uma opção específica.
+     *
+     * @param index Índice lógico da opção alvo.
+     * @returns `true` quando a opção foi encontrada para foco.
+     */
+    async focusOption(index) {
+        const filteredOptions = this.getFilteredOptions();
+        if (index < 0 || index >= filteredOptions.length)
+            return false;
+        await this.ensureOptionVisible(index);
+        let optionElement = this.getOptionElement(index);
+        if (!optionElement) {
+            await this.waitForNextFrame();
+            optionElement = this.getOptionElement(index);
+        }
+        await optionElement?.setFocus?.();
+        return Boolean(optionElement);
+    }
+    /**
+     * Aciona a seleção programática de uma opção específica.
+     *
+     * @param index Índice lógico da opção alvo.
+     * @param selected Estado desejado para a opção. Quando omitido, a própria opção alterna o valor atual.
+     * @returns `true` quando a opção foi encontrada para atualização.
+     */
+    async setOptionSelected(index, selected) {
+        const filteredOptions = this.getFilteredOptions();
+        if (index < 0 || index >= filteredOptions.length)
+            return false;
+        await this.ensureOptionVisible(index);
+        let optionElement = this.getOptionElement(index);
+        if (!optionElement) {
+            await this.waitForNextFrame();
+            optionElement = this.getOptionElement(index);
+        }
+        await optionElement?.setSelectedState?.(selected);
+        return Boolean(optionElement);
+    }
+    applyMultipleOption(detail) {
+        if (this.isSelectAllOption(detail)) {
+            this.toggleAllOptions(Boolean(detail.selected));
+            return;
+        }
+        const nextOptions = this.options.map((option) => {
+            if (option.value !== detail.value)
+                return option;
+            return {
+                ...option,
+                ...detail,
+                indeterminate: false,
+                selected: Boolean(detail.selected),
+            };
+        });
+        this.options = this.syncSelectAllOption(nextOptions);
+    }
+    applySingleSelect(detail) {
+        const exists = this.options.some((o) => o.value === detail.value);
+        if (exists) {
+            this.options = this.options.map((o) => ({ ...o, selected: o.value === detail.value }));
+            return;
+        }
+        const newOpt = {
+            value: detail.value,
+            label: detail.label ?? detail.value,
+            selected: true,
+        };
+        this.options = [newOpt, ...this.options.map((o) => ({ ...o, selected: false }))];
+    }
+    clearSingleSelection() {
+        this.options = this.options.map((o) => ({ ...o, selected: false }));
+    }
+    isSelectAllOption(option) {
+        if (option.value === SelectList.SELECT_ALL_VALUE)
+            return true;
+        const optionLabel = (option.label ?? option.value).trim();
+        return optionLabel === this.selectAllLabel || optionLabel === this.unselectAllLabel;
+    }
+    isSelectableOption(option) {
+        return !this.isSelectAllOption(option);
+    }
+    getSelectableOptions(options) {
+        return options.filter((option) => this.isSelectableOption(option));
+    }
+    getSelectAllLabel(selected, indeterminate) {
+        return selected && !indeterminate ? this.unselectAllLabel : this.selectAllLabel;
+    }
+    createSelectAllOption() {
+        return {
+            value: SelectList.SELECT_ALL_VALUE,
+            label: this.selectAllLabel,
+            selected: false,
+            indeterminate: false,
+            disabled: false,
+        };
+    }
+    normalizeSelectAllOption(option) {
+        if (!this.isSelectAllOption(option))
+            return option;
+        const selected = Boolean(option.selected) && !option.indeterminate;
+        const indeterminate = Boolean(option.indeterminate);
+        return {
+            ...option,
+            indeterminate,
+            label: this.getSelectAllLabel(selected, indeterminate),
+            selected,
+        };
+    }
+    toggleAllOptions(selected) {
+        const nextOptions = this.getSelectableOptions(this.options).map((option) => ({
+            ...option,
+            selected,
+            indeterminate: false,
+        }));
+        this.options = this.syncSelectAllOption(nextOptions);
+    }
+    syncSelectAllOption(options) {
+        const selectableOptions = this.getSelectableOptions(options).map((option) => ({
+            ...option,
+            indeterminate: false,
+        }));
+        const allSelected = selectableOptions.length > 0 && selectableOptions.every((option) => Boolean(option.selected));
+        const anySelected = selectableOptions.some((option) => Boolean(option.selected));
+        return [
+            this.normalizeSelectAllOption({
+                ...this.createSelectAllOption(),
+                indeterminate: anySelected && !allSelected,
+                selected: allSelected,
+            }),
+            ...selectableOptions,
+        ];
+    }
+    normalizeOptionsForMode(options, isMultiple) {
+        const selectableOptions = this.getSelectableOptions(options);
+        if (isMultiple) {
+            return this.syncSelectAllOption(selectableOptions);
+        }
+        let hasSelectedOption = false;
+        return selectableOptions.map((option) => {
+            const shouldSelect = Boolean(option.selected) && !hasSelectedOption;
+            if (shouldSelect) {
+                hasSelectedOption = true;
+            }
+            return {
+                ...option,
+                indeterminate: false,
+                selected: shouldSelect,
+            };
+        });
+    }
+    normalizeSearchText(value) {
+        return (value ?? '')
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLocaleLowerCase('pt-BR')
+            .trim();
+    }
+    getFilteredOptions() {
+        const normalizedTerm = this.normalizeSearchText(this.searchTerm);
+        const cacheKey = `${normalizedTerm}|${this.isMultiple}|${this.selectAllLabel}|${this.unselectAllLabel}|${this.options.length}`;
+        if (this.options === this.filteredOptionsCacheSource &&
+            cacheKey === this.filteredOptionsCacheKey &&
+            this.filteredOptionsCache !== null) {
+            return this.filteredOptionsCache;
+        }
+        this.filteredOptionsCacheSource = this.options;
+        if (!normalizedTerm) {
+            this.filteredOptionsCacheKey = cacheKey;
+            this.filteredOptionsCache = this.options;
+            return this.options;
+        }
+        this.filteredOptionsCacheKey = cacheKey;
+        this.filteredOptionsCache = this.options.filter((option) => {
+            if (this.isSelectAllOption(option))
+                return this.isMultiple;
+            const label = this.normalizeSearchText(option.label ?? option.value);
+            const value = this.normalizeSearchText(option.value);
+            return label.includes(normalizedTerm) || value.includes(normalizedTerm);
+        });
+        return this.filteredOptionsCache;
+    }
+    getViewportHeight() {
+        const visibleOptionCount = Math.min(this.getFilteredOptions().length, this.visibleItems);
+        return visibleOptionCount * this.getRowHeight();
+    }
+    getRowHeight() {
+        return this.measuredItemHeight ?? this.itemHeight;
+    }
+    getVisibleRange() {
+        const filteredOptions = this.getFilteredOptions();
+        if (filteredOptions.length === 0) {
+            return { startIndex: 0, endIndex: 0 };
+        }
+        const rowHeight = this.getRowHeight();
+        const firstVisibleIndex = Math.floor(this.scrollTop / rowHeight);
+        const startIndex = Math.max(0, firstVisibleIndex - this.overscan);
+        const endIndex = Math.min(filteredOptions.length, firstVisibleIndex + this.visibleItems + this.overscan);
+        return { startIndex, endIndex };
+    }
+    clampScrollPosition() {
+        if (!this.listElement)
+            return;
+        const totalHeight = this.getFilteredOptions().length * this.getRowHeight();
+        const maxScrollTop = Math.max(0, totalHeight - this.getViewportHeight());
+        const nextScrollTop = Math.min(Math.max(0, this.listElement.scrollTop), maxScrollTop);
+        if (this.listElement.scrollTop !== nextScrollTop) {
+            this.listElement.scrollTop = nextScrollTop;
+        }
+        if (this.scrollTop !== nextScrollTop) {
+            this.scrollTop = nextScrollTop;
+        }
+    }
+    scheduleMeasureItemHeight() {
+        if (this.getFilteredOptions().length === 0)
+            return;
+        if (this.measurementFrame !== null)
+            return;
+        this.measurementFrame = requestAnimationFrame(async () => {
+            this.measurementFrame = null;
+            await this.measureItemHeight();
+        });
+    }
+    async measureItemHeight() {
+        const firstOption = this.listElement?.querySelector('br-select-option');
+        if (!firstOption?.getItemHeight)
+            return;
+        const nextHeight = await firstOption.getItemHeight();
+        if (!nextHeight || nextHeight <= 0 || nextHeight === this.measuredItemHeight)
+            return;
+        this.measuredItemHeight = nextHeight;
+        this.clampScrollPosition();
+    }
+    /**
+     * Localiza a opção renderizada correspondente a um índice lógico da lista.
+     *
+     * @param index Índice da opção dentro da coleção atual.
+     * @returns O elemento da opção, quando presente no DOM.
+     */
+    getOptionElement(index) {
+        return this.el.shadowRoot?.querySelector(`br-select-option[data-option-index="${index}"]`);
+    }
+    async ensureOptionVisible(index) {
+        if (!this.listElement)
+            return;
+        const rowHeight = this.getRowHeight();
+        const viewportHeight = this.getViewportHeight();
+        const optionTop = index * rowHeight;
+        const optionBottom = optionTop + rowHeight;
+        const viewportTop = this.listElement.scrollTop;
+        const viewportBottom = viewportTop + viewportHeight;
+        let nextScrollTop = viewportTop;
+        if (optionTop < viewportTop) {
+            nextScrollTop = optionTop;
+        }
+        else if (optionBottom > viewportBottom) {
+            nextScrollTop = optionBottom - viewportHeight;
+        }
+        const maxScrollTop = Math.max(0, this.getFilteredOptions().length * rowHeight - viewportHeight);
+        nextScrollTop = Math.min(Math.max(0, nextScrollTop), maxScrollTop);
+        if (nextScrollTop === viewportTop)
+            return;
+        this.listElement.scrollTop = nextScrollTop;
+        this.scrollTop = nextScrollTop;
+        await this.waitForNextFrame();
+    }
+    getCssClassMap() {
+        return {
+            'br-select-list': true,
+            'is-open': this.isOpen,
+        };
+    }
+    renderOption(option, index) {
+        const rowHeight = this.getRowHeight();
+        const optionPart = this.isSelectAllOption(option) ? 'option select-all' : 'option';
+        return (h("br-select-option", { part: optionPart, active: index === this.activeOptionIndex, "data-option-index": index, disabled: option.disabled, id: `${this.el.id || 'br-select-list'}-option-${index}`, indeterminate: option.indeterminate, key: option.value, label: option.label, selected: option.selected, "show-checkbox": this.isMultiple, style: {
+                boxSizing: 'border-box',
+                height: `${rowHeight}px`,
+                position: 'absolute',
+                top: `${index * rowHeight}px`,
+                left: '0',
+                right: '0',
+            }, value: option.value }, option.label ?? option.value));
+    }
+    getVirtualScrollStyle() {
+        return {
+            height: `${this.getViewportHeight()}px`,
+            overflowY: 'auto',
+            overflowX: 'hidden',
+        };
+    }
+    getVirtualSpacerStyle() {
+        return {
+            height: `${this.getFilteredOptions().length * this.getRowHeight()}px`,
+            position: 'relative',
+        };
+    }
+    getVirtualVisibleOptions() {
+        const filteredOptions = this.getFilteredOptions();
+        const { startIndex, endIndex } = this.getVisibleRange();
+        return {
+            startIndex,
+            visibleOptions: filteredOptions.slice(startIndex, endIndex),
+        };
+    }
+    renderVirtualOptions() {
+        const { startIndex, visibleOptions } = this.getVirtualVisibleOptions();
+        if (visibleOptions.length === 0) {
+            return (h("div", { part: "empty-option", role: "option", "aria-selected": "false", tabIndex: 0 }, "Nenhum resultado encontrado"));
+        }
+        return (h("div", { style: this.getVirtualSpacerStyle() }, visibleOptions.map((option, relativeIndex) => this.renderOption(option, startIndex + relativeIndex))));
+    }
+    renderLoading() {
+        return (h("div", { part: "loading", role: "status", "aria-live": "polite" }, h("slot", { name: "loading" }, h("br-loading", { size: "small", label: "Buscando op\u00E7\u00F5es" }))));
+    }
+    render() {
+        return (h(Host, { key: '5dc8eb2363f8deae198dade6003ded206eb959a4' }, h("div", { key: '6cc0273ab1143d29114090ea7edde1b49d217fe8', class: this.getCssClassMap(), part: "list", ref: (el) => (this.listElement = el), onScroll: this.handleScroll, style: this.getVirtualScrollStyle() }, this.loading ? this.renderLoading() : this.renderVirtualOptions())));
+    }
+    static get is() { return "br-select-list"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["select-list.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["select-list.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "options": {
+                "type": "unknown",
+                "mutable": true,
+                "complexType": {
+                    "original": "SelectOptionData[]",
+                    "resolved": "SelectOptionData[]",
+                    "references": {
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "../select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "type",
+                            "text": "{SelectOptionData[]}"
+                        }, {
+                            "name": "default",
+                            "text": "[]"
+                        }],
+                    "text": "Cole\u00E7\u00E3o de op\u00E7\u00F5es exibidas pela lista."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[]"
+            },
+            "searchTerm": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "''"
+                        }],
+                    "text": "Termo usado para filtrar op\u00E7\u00F5es por r\u00F3tulo ou valor."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "search-term",
+                "defaultValue": "''"
+            },
+            "loading": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Indica que os resultados remotos est\u00E3o sendo carregados."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "loading",
+                "defaultValue": "false"
+            },
+            "visibleItems": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "6"
+                        }],
+                    "text": "Define quantas op\u00E7\u00F5es permanecem vis\u00EDveis na viewport da lista."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "visible-items",
+                "defaultValue": "6"
+            },
+            "itemHeight": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "56"
+                        }],
+                    "text": "Informa a altura base usada no c\u00E1lculo de posicionamento das op\u00E7\u00F5es."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "item-height",
+                "defaultValue": "56"
+            },
+            "overscan": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "0"
+                        }],
+                    "text": "Define quantas op\u00E7\u00F5es extras s\u00E3o renderizadas fora da viewport quando o virtual scroll est\u00E1 ativo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "overscan",
+                "defaultValue": "0"
+            },
+            "selectAllLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Selecionar todos'"
+                        }],
+                    "text": "R\u00F3tulo apresentado para a a\u00E7\u00E3o de selecionar todos no modo m\u00FAltiplo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "select-all-label",
+                "defaultValue": "SelectList.SELECT_ALL_LABEL"
+            },
+            "unselectAllLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Desselecionar todos'"
+                        }],
+                    "text": "R\u00F3tulo apresentado quando todas as op\u00E7\u00F5es j\u00E1 est\u00E3o selecionadas no modo m\u00FAltiplo."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "unselect-all-label",
+                "defaultValue": "SelectList.DESELECT_ALL_LABEL"
+            },
+            "activeOptionIndex": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "-1"
+                        }, {
+                            "name": "remarks",
+                            "text": "Esse valor \u00E9 usado para refletir visualmente o foco l\u00F3gico da lista."
+                        }],
+                    "text": "\u00CDndice da op\u00E7\u00E3o atualmente ativa para navega\u00E7\u00E3o por teclado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "active-option-index",
+                "defaultValue": "-1"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isOpen": {},
+            "isMultiple": {},
+            "scrollTop": {},
+            "measuredItemHeight": {}
+        };
+    }
+    static get methods() {
+        return {
+            "open": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Abre a lista e agenda a medi\u00E7\u00E3o das op\u00E7\u00F5es quando necess\u00E1rio.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "close": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Fecha a lista de op\u00E7\u00F5es.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do estado."
+                        }]
+                }
+            },
+            "setOptions": {
+                "complexType": {
+                    "signature": "(options: SelectOptionData[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "options",
+                            "type": "SelectOptionData[]",
+                            "docs": "Nova cole\u00E7\u00E3o de op\u00E7\u00F5es normalizadas."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "../select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Substitui todas as op\u00E7\u00F5es renderizadas pela lista.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "options Nova cole\u00E7\u00E3o de op\u00E7\u00F5es normalizadas."
+                        }, {
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o da lista."
+                        }]
+                }
+            },
+            "setOption": {
+                "complexType": {
+                    "signature": "(option: SelectOptionData) => Promise<void>",
+                    "parameters": [{
+                            "name": "option",
+                            "type": "{ disabled?: boolean; indeterminate?: boolean; label?: string; selected?: boolean; value: string; }",
+                            "docs": "Op\u00E7\u00E3o que deve ser persistida na lista."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "../select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Adiciona ou atualiza uma \u00FAnica op\u00E7\u00E3o na cole\u00E7\u00E3o atual.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "option Op\u00E7\u00E3o que deve ser persistida na lista."
+                        }, {
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o da cole\u00E7\u00E3o."
+                        }]
+                }
+            },
+            "setSearchTerm": {
+                "complexType": {
+                    "signature": "(term: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "term",
+                            "type": "string",
+                            "docs": "Termo que deve filtrar a cole\u00E7\u00E3o. String vazia restaura todas as op\u00E7\u00F5es."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Atualiza o termo de busca e reinicia a janela virtual no topo.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "term Termo que deve filtrar a cole\u00E7\u00E3o. String vazia restaura todas as op\u00E7\u00F5es."
+                        }]
+                }
+            },
+            "setMultiple": {
+                "complexType": {
+                    "signature": "(isMultiple: boolean) => Promise<void>",
+                    "parameters": [{
+                            "name": "isMultiple",
+                            "type": "boolean",
+                            "docs": "Define se a lista deve operar em sele\u00E7\u00E3o m\u00FAltipla."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Alterna a lista entre modo simples e m\u00FAltiplo.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "isMultiple Define se a lista deve operar em sele\u00E7\u00E3o m\u00FAltipla."
+                        }, {
+                            "name": "returns",
+                            "text": "Uma promise conclu\u00EDda ap\u00F3s a atualiza\u00E7\u00E3o do modo."
+                        }]
+                }
+            },
+            "getOptions": {
+                "complexType": {
+                    "signature": "() => Promise<SelectOptionData[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "SelectOptionData": {
+                            "location": "import",
+                            "path": "../select.types",
+                            "id": "src/components/select/select.types.ts::SelectOptionData",
+                            "referenceLocation": "SelectOptionData"
+                        }
+                    },
+                    "return": "Promise<SelectOptionData[]>"
+                },
+                "docs": {
+                    "text": "Retorna uma c\u00F3pia das op\u00E7\u00F5es atualmente controladas pela lista.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "As op\u00E7\u00F5es renderizadas no estado atual."
+                        }]
+                }
+            },
+            "scrollOptionToTop": {
+                "complexType": {
+                    "signature": "(index: number) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "index",
+                            "type": "number",
+                            "docs": "\u00CDndice l\u00F3gico da op\u00E7\u00E3o alvo."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Posiciona uma op\u00E7\u00E3o no topo da viewport virtual, respeitando o limite final da lista.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "index \u00CDndice l\u00F3gico da op\u00E7\u00E3o alvo."
+                        }, {
+                            "name": "returns",
+                            "text": "`true` quando o \u00EDndice pertence \u00E0 cole\u00E7\u00E3o filtrada atual."
+                        }]
+                }
+            },
+            "scrollFirstSelectedOptionToTop": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Posiciona no topo a primeira op\u00E7\u00E3o selecionada na ordem visual da lista.\nA op\u00E7\u00E3o auxiliar de selecionar tudo n\u00E3o participa dessa escolha.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "`true` quando existe uma op\u00E7\u00E3o selecionada para posicionar."
+                        }]
+                }
+            },
+            "focusOption": {
+                "complexType": {
+                    "signature": "(index: number) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "index",
+                            "type": "number",
+                            "docs": "\u00CDndice l\u00F3gico da op\u00E7\u00E3o alvo."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Garante visibilidade e foco para uma op\u00E7\u00E3o espec\u00EDfica.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "index \u00CDndice l\u00F3gico da op\u00E7\u00E3o alvo."
+                        }, {
+                            "name": "returns",
+                            "text": "`true` quando a op\u00E7\u00E3o foi encontrada para foco."
+                        }]
+                }
+            },
+            "setOptionSelected": {
+                "complexType": {
+                    "signature": "(index: number, selected?: boolean) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "index",
+                            "type": "number",
+                            "docs": "\u00CDndice l\u00F3gico da op\u00E7\u00E3o alvo."
+                        }, {
+                            "name": "selected",
+                            "type": "boolean",
+                            "docs": "Estado desejado para a op\u00E7\u00E3o. Quando omitido, a pr\u00F3pria op\u00E7\u00E3o alterna o valor atual."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Aciona a sele\u00E7\u00E3o program\u00E1tica de uma op\u00E7\u00E3o espec\u00EDfica.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "index \u00CDndice l\u00F3gico da op\u00E7\u00E3o alvo."
+                        }, {
+                            "name": "param",
+                            "text": "selected Estado desejado para a op\u00E7\u00E3o. Quando omitido, a pr\u00F3pria op\u00E7\u00E3o alterna o valor atual."
+                        }, {
+                            "name": "returns",
+                            "text": "`true` quando a op\u00E7\u00E3o foi encontrada para atualiza\u00E7\u00E3o."
+                        }]
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "searchTerm",
+                "methodName": "handleSearchTermChange"
+            }, {
+                "propName": "selectAllLabel",
+                "methodName": "handleSelectAllLabelChange"
+            }, {
+                "propName": "unselectAllLabel",
+                "methodName": "handleSelectAllLabelChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "brSelectOptionStateChange",
+                "method": "handleOptionStateChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}
+SelectList.SELECT_ALL_LABEL = 'Selecionar todos';
+SelectList.DESELECT_ALL_LABEL = 'Desselecionar todos';
+SelectList.SELECT_ALL_VALUE = 'Alternar todos';