@govbr-ds/webcomponents 2.1.0 → 2.1.1

package/dist/collection/components/table/table.js

@@ -0,0 +1,1030 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h } from "@stencil/core";
+import { generateUniqueId } from "../../shared/utils/id";
+import { COLUMN_WIDTH_MAP, COLUMN_WIDTH_SEMANTICS, TABLE_ALIGNMENT, TABLE_ALIGNMENT_MAP, TABLE_DENSITY, TABLE_DENSITY_MAP, TABLE_DIVIDER_STYLE, TABLE_DIVIDER_STYLE_MAP, TABLE_OVERFLOW, TABLE_OVERFLOW_MAP, TABLE_TOOLTIP_STATE, } from "./table-constants";
+import { TABLE_TOKENS } from "./table-tokens";
+import { positiveFrValidator, positivePxValidator, resolveTokenValue } from "./table-utils";
+/**
+ * ## Design System
+ *
+ * Tabela baseada em CSS Grid com controle via tokens.
+ *
+ * A tabela é composta de vários subcomponentes, incluindo:
+ * - br-table-header: Define o cabeçalho da tabela, agrupando as linhas de cabeçalho.
+ * - br-table-row: Representa uma linha da tabela, podendo conter células de conteúdo ou células de cabeçalho.
+ * - br-table-header-cell: Representa uma célula de cabeçalho, permitindo a definição de propriedades como largura e alinhamento que podem ser herdadas pelas células de conteúdo associadas.
+ * - br-table-cell: Representa uma célula de conteúdo da tabela, onde os dados são inseridos.
+ * - br-table-body: Agrupa as linhas de conteúdo da tabela, representadas pelo subcomponente br-table-row.
+ *
+ * @remarks
+ * 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/table?tab=designer).
+ *
+ * @category Dados
+ * @status stable
+ * @Slot header: Área para inclusão do subcomponente br-table-header
+ * @Slot body: Área para inclusão do subcomponente br-table-body
+ * @slot loading - Indicador exibido enquanto as linhas são atualizadas.
+ *
+ * @part container - Wrapper principal da tabela.
+ * @part content - Área de conteúdo que contém header e body.
+ * @part loading - Área do indicador de carregamento.
+ */
+export class Table {
+    constructor() {
+        /**
+         * Ativa divisores verticais entre colunas.
+         *
+         * @default false
+         * @deprecated Use `columnDivider`.
+         */
+        this.hasColumnDivider = false;
+        /**
+         * Ativa divisores horizontais entre linhas.
+         *
+         * @default false
+         * @deprecated Use `rowDivider`.
+         */
+        this.hasRowDivider = false;
+        /**
+         * Define o comportamento de overflow para as células.
+         *
+         * @remarks Valores aceitos:
+         * - truncate
+         * - wrap
+         *
+         * Observação:
+         * - O overflow é independente de `columnWidth`.
+         * - Com `columnWidth="content"`, a coluna tende a crescer com o conteúdo (`max-content`), o que pode reduzir casos visíveis de truncagem.
+         * - Com `columnWidth="fill"`, a coluna ocupa o espaço disponível (`1fr`), então a truncagem tende a ficar mais evidente quando não há espaço suficiente.
+         *
+         * @default wrap
+         */
+        this.overflow = TABLE_OVERFLOW.WRAP;
+        /**
+         * Define o estado semântico do tooltip nas células da tabela.
+         *
+         * @remarks Valores aceitos:
+         * - info
+         * - warning
+         * - danger
+         * - success
+         *
+         * @default info
+         */
+        this.tooltipState = TABLE_TOOLTIP_STATE.INFO;
+        /**
+         * Indica que as linhas estão sendo atualizadas pelo consumidor.
+         * O componente mantém o conteúdo anterior, aplica `aria-busy="true"` e
+         * exibe o slot `loading` sobre os dados; transporte, erro e substituição das
+         * linhas ficam sob responsabilidade da aplicação.
+         * A prop pode ser alterada diretamente ou pelos métodos `startLoading()` e
+         * `stopLoading()`.
+         * @default false
+         */
+        this.loading = false;
+        this.headers = [];
+        this.rows = [];
+        this.cells = [];
+        this.rowCells = new Map();
+        this.columnIndexes = new Map();
+        this.structureReady = false;
+        this.structureRefreshFrame = null;
+        this.handleColumnWidthEvent = () => {
+            this.scheduleStructureRefresh();
+        };
+        this.handleAlignmentEvent = (event) => {
+            if (!this.structureReady) {
+                this.scheduleStructureRefresh();
+                return;
+            }
+            this.updateAlignmentForTarget(event.target);
+        };
+        this.handleOverflowEvent = (event) => {
+            if (!this.structureReady) {
+                this.scheduleStructureRefresh();
+                return;
+            }
+            this.updateOverflowForTarget(event.target);
+        };
+        this.generatedHeaderPrefix = generateUniqueId();
+        /**
+         * Recalcula estrutura, tokens e metadados de acessibilidade quando há mudança de slots.
+         */
+        this.handleStructureChange = () => {
+            this.scheduleStructureRefresh();
+        };
+    }
+    /**
+     * Reaplica a largura das colunas quando alterada.
+     */
+    handleTableColumnWidthChange() {
+        this.updateColumnWidths();
+    }
+    /**
+     * Reaplica o token de densidade quando alterado.
+     */
+    handleDensityChange() {
+        this.applyDensity();
+    }
+    /**
+     * Atualiza os tokens de divisor quando qualquer propriedade relacionada é alterada.
+     */
+    handleDividerChange() {
+        this.applyDividers();
+    }
+    /**
+     * Atualiza os tokens de alinhamento quando alterados.
+     */
+    handleAlignmentChange() {
+        this.updateAllCellAlignments();
+    }
+    /**
+     * Atualiza os tokens de overflow quando a propriedade é alterada.
+     */
+    handleOverflowChange() {
+        this.updateAllCellOverflow();
+    }
+    /**
+     * Ciclo de vida do componente que é chamado após o componente ser carregado no DOM.
+     * Inicializa os tokens visuais após a montagem do componente.
+     */
+    componentDidLoad() {
+        this.refreshStructure();
+        this.applyDensity();
+        this.applyDividers();
+        // garante cálculo inicial após filhos renderizarem
+        queueMicrotask(() => {
+            this.updateColumnWidths();
+            this.updateAllCellAlignments();
+            this.updateAllCellOverflow();
+            this.applyAriaMetadata();
+        });
+    }
+    connectedCallback() {
+        this.el.addEventListener('brColumnWidthChange', this.handleColumnWidthEvent);
+        this.el.addEventListener('brAlignmentChange', this.handleAlignmentEvent);
+        this.el.addEventListener('brOverflowChange', this.handleOverflowEvent);
+    }
+    disconnectedCallback() {
+        this.el.removeEventListener('brColumnWidthChange', this.handleColumnWidthEvent);
+        this.el.removeEventListener('brAlignmentChange', this.handleAlignmentEvent);
+        this.el.removeEventListener('brOverflowChange', this.handleOverflowEvent);
+        if (this.structureRefreshFrame !== null) {
+            cancelAnimationFrame(this.structureRefreshFrame);
+            this.structureRefreshFrame = null;
+        }
+    }
+    /** Inicia o estado de carregamento da tabela. */
+    async startLoading() {
+        this.loading = true;
+    }
+    /** Interrompe o estado de carregamento da tabela. */
+    async stopLoading() {
+        this.loading = false;
+    }
+    /**
+     * Marca a última linha e a última coluna para permitir estilização condicional.
+     */
+    refreshStructure() {
+        this.headers = Array.from(this.el.querySelectorAll('br-table-header-cell'));
+        this.rows = Array.from(this.el.querySelectorAll('br-table-row'));
+        this.cells = [...this.headers, ...Array.from(this.el.querySelectorAll('br-table-cell'))];
+        this.rowCells.clear();
+        this.columnIndexes.clear();
+        const columnCount = this.headers.length;
+        this.headers.forEach((column, columnIndex) => {
+            if (!(column instanceof HTMLElement))
+                return;
+            const isLastColumn = columnIndex === columnCount - 1;
+            column.toggleAttribute('data-last-column', isLastColumn);
+            this.columnIndexes.set(column, columnIndex);
+        });
+        this.rows.forEach((row, rowIndex) => {
+            const isLastRow = rowIndex === this.rows.length - 1;
+            const rowCells = Array.from(row.querySelectorAll('br-table-cell, br-table-header-cell'));
+            this.rowCells.set(row, rowCells);
+            rowCells.forEach((cell, columnIndex) => {
+                if (!(cell instanceof HTMLElement))
+                    return;
+                const isLastColumn = columnIndex === columnCount - 1;
+                cell.toggleAttribute('data-last-row', isLastRow);
+                cell.toggleAttribute('data-last-column', isLastColumn);
+                this.columnIndexes.set(cell, columnIndex);
+            });
+        });
+        this.structureReady = true;
+    }
+    scheduleStructureRefresh() {
+        if (this.structureRefreshFrame !== null)
+            return;
+        this.structureRefreshFrame = requestAnimationFrame(() => {
+            this.structureRefreshFrame = null;
+            this.refreshStructure();
+            this.updateColumnWidths();
+            this.updateAllCellAlignments();
+            this.updateAllCellOverflow();
+            this.applyAriaMetadata();
+        });
+    }
+    /**
+     * Atualiza a largura das colunas com base nos cabeçalhos.
+     * @returns void
+     */
+    updateColumnWidths() {
+        const headers = this.getHeaderCells();
+        if (headers.length === 0)
+            return;
+        const template = this.buildGridTemplate(headers);
+        this.applyGridTemplate(template);
+    }
+    /**
+     * Constrói o template de grid para a tabela com base nos cabeçalhos.
+     * @param headers Os elementos de cabeçalho da tabela.
+     * @returns Uma string representando o template de grid CSS.
+     */
+    buildGridTemplate(headers) {
+        const tableWidth = this.resolveTableColumnWidth();
+        const columnWidths = headers.map((header) => this.resolveColumnWidth(header, tableWidth));
+        return columnWidths.join(' ');
+    }
+    /**
+     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
+     */
+    resolveTableColumnWidth() {
+        return this.resolveWidthToken(this.columnWidth, COLUMN_WIDTH_MAP[COLUMN_WIDTH_SEMANTICS.FILL]);
+    }
+    /**
+     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
+     * @param header O elemento de cabeçalho da coluna.
+     * @param fallback A largura de fallback a ser usada caso o cabeçalho não defina uma largura.
+     * @returns A largura resolvida da coluna.
+     */
+    resolveColumnWidth(header, fallback) {
+        const headerWidth = header.getAttribute('column-width');
+        return this.resolveWidthToken(headerWidth, fallback);
+    }
+    /**
+     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
+     * @param raw O template de grid bruto a ser aplicado.
+     * @param fallback O template de grid de fallback a ser usado caso o valor bruto seja inválido.
+     * @return void
+     */
+    resolveWidthToken(raw, fallback) {
+        return resolveTokenValue(raw ?? undefined, {
+            fallback,
+            semanticMap: COLUMN_WIDTH_MAP,
+            validators: [positivePxValidator, positiveFrValidator],
+        });
+    }
+    /**
+     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
+     * @param template O template de grid a ser aplicado.
+     */
+    applyGridTemplate(template) {
+        this.el.style.setProperty(TABLE_TOKENS.COLUMN_WIDTHS, template);
+    }
+    /**
+     * Atualiza o alinhamento de todas as células da tabela com base nos tokens de alinhamento.
+     */
+    updateAllCellAlignments() {
+        const cells = this.getAllCells();
+        cells.forEach((cell) => {
+            this.updateAlignmentForCell(cell);
+        });
+    }
+    /**
+     * Atualiza o alinhamento de uma célula específica com base nos tokens de alinhamento.
+     * @param cell A célula a ser atualizada.
+     */
+    updateAlignmentForCell(cell) {
+        const horizontal = this.resolveHorizontalAlignmentForCell(cell);
+        const vertical = this.resolveVerticalAlignmentForCell(cell);
+        cell.style.setProperty(TABLE_TOKENS.HORIZONTAL_ALIGNMENT, horizontal);
+        cell.style.setProperty(TABLE_TOKENS.VERTICAL_ALIGNMENT, vertical);
+    }
+    /**
+     * Resolve o alinhamento horizontal de uma célula específica com base nos tokens de alinhamento.
+     * @param cell A célula a ser avaliada.
+     * @returns O valor do token de alinhamento horizontal resolvido.
+     */
+    resolveHorizontalAlignmentForCell(cell) {
+        // Cell
+        const cellValue = cell.getAttribute('horizontal-alignment');
+        if (cellValue !== null)
+            return this.resolveAlignmentToken(cellValue);
+        // Row
+        const row = cell.closest('br-table-row');
+        const rowValue = row?.getAttribute('horizontal-alignment');
+        if (rowValue !== null)
+            return this.resolveAlignmentToken(rowValue);
+        // Column (header)
+        const columnValue = this.getColumnAlignment(cell, 'horizontal-alignment');
+        if (columnValue !== null)
+            return this.resolveAlignmentToken(columnValue);
+        // Table
+        if (this.horizontalAlignment !== undefined)
+            return this.resolveAlignmentToken(this.horizontalAlignment);
+        // Fallback
+        return TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START];
+    }
+    /**
+     * Resolve o alinhamento vertical de uma célula específica com base nos tokens de alinhamento.
+     * @param cell A célula a ser avaliada.
+     * @returns O valor do token de alinhamento vertical resolvido.
+     */
+    resolveVerticalAlignmentForCell(cell) {
+        const cellValue = cell.getAttribute('vertical-alignment');
+        if (cellValue !== null)
+            return this.resolveAlignmentToken(cellValue);
+        const row = cell.closest('br-table-row');
+        const rowValue = row?.getAttribute('vertical-alignment');
+        if (rowValue !== null)
+            return this.resolveAlignmentToken(rowValue);
+        const columnValue = this.getColumnAlignment(cell, 'vertical-alignment');
+        if (columnValue !== null)
+            return this.resolveAlignmentToken(columnValue);
+        if (this.verticalAlignment !== undefined)
+            return this.resolveAlignmentToken(this.verticalAlignment);
+        return TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START];
+    }
+    /**
+     * Resolve um valor de token de alinhamento com base no valor bruto e no mapeamento semântico definido.
+     * @param value O valor bruto do token de alinhamento a ser resolvido.
+     * @returns O valor do token de alinhamento resolvido, ou o valor de fallback se o valor bruto for inválido.
+     */
+    resolveAlignmentToken(value) {
+        return resolveTokenValue(value ?? undefined, {
+            fallback: TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START],
+            semanticMap: TABLE_ALIGNMENT_MAP,
+        });
+    }
+    /**
+     * Retorna o valor do atributo de alinhamento de uma coluna específica.
+     * @param cell A célula para a qual o alinhamento da coluna deve ser obtido.
+     * @param attribute O atributo de alinhamento a ser obtido ('horizontal-alignment' ou 'vertical-alignment').
+     * @returns O valor do atributo de alinhamento da coluna, ou null se não estiver definido.
+     */
+    getColumnAlignment(cell, attribute) {
+        const columnIndex = this.getColumnIndex(cell);
+        if (columnIndex === -1)
+            return null;
+        const headers = this.getHeaderCells();
+        const header = headers[columnIndex];
+        return header?.getAttribute(attribute) ?? null;
+    }
+    /**
+     * Obtém o índice da coluna para uma célula específica, permitindo a associação entre células e seus respectivos cabeçalhos para herança de propriedades como alinhamento e largura.
+     * @param cell A célula para a qual o índice da coluna deve ser obtido.
+     * @returns O índice da coluna correspondente à célula, ou -1 se a célula não estiver dentro de uma linha válida.
+     */
+    getColumnIndex(cell) {
+        return this.columnIndexes.get(cell) ?? -1;
+    }
+    /**
+     * Constrói o template de grid para a tabela com base nos cabeçalhos.
+     * @return Array de larguras de coluna resolvidas.
+     */
+    getHeaderCells() {
+        return this.headers;
+    }
+    /**
+     * Obtém todas as células (tanto de corpo quanto de cabeçalho) da tabela, permitindo a aplicação de estilos e tokens de forma abrangente.
+     * @returns Um array contendo todas as células da tabela.
+     */
+    getAllCells() {
+        return this.cells;
+    }
+    /**
+     * Aplica metadados ARIA para melhorar a navegação por leitores de tela.
+     */
+    applyAriaMetadata() {
+        const rows = this.rows;
+        const headers = this.getHeaderCells();
+        this.el.setAttribute('aria-colcount', String(headers.length));
+        this.el.setAttribute('aria-rowcount', String(rows.length));
+        rows.forEach((row, rowIndex) => {
+            row.setAttribute('aria-rowindex', String(rowIndex + 1));
+        });
+        headers.forEach((header, headerIndex) => {
+            const colIndex = String(headerIndex + 1);
+            const headerId = header.id || `${this.generatedHeaderPrefix}-${headerIndex + 1}`;
+            header.id = headerId;
+            header.setAttribute('aria-colindex', colIndex);
+        });
+        const bodyCells = this.cells.filter((cell) => cell.tagName === 'BR-TABLE-CELL');
+        bodyCells.forEach((cell) => {
+            const columnIndex = this.getColumnIndex(cell);
+            if (columnIndex === -1)
+                return;
+            const colIndex = String(columnIndex + 1);
+            const header = headers[columnIndex];
+            cell.setAttribute('aria-colindex', colIndex);
+            if (header !== undefined && header.id !== '') {
+                cell.setAttribute('aria-labelledby', header.id);
+            }
+        });
+    }
+    /**
+     * Atualiza os tokens de overflow para todas as células da tabela, garantindo que as mudanças na propriedade de overflow sejam refletidas dinamicamente em todas as células, controlando o comportamento de overflow, text-overflow e white-space conforme definido no token.
+     */
+    updateAllCellOverflow() {
+        this.getAllCells().forEach((cell) => {
+            this.updateOverflowForCell(cell);
+        });
+    }
+    updateAlignmentForTarget(target) {
+        if (target === null || !this.el.contains(target))
+            return;
+        if (target.tagName === 'BR-TABLE-CELL' || target.tagName === 'BR-TABLE-HEADER-CELL') {
+            this.updateAlignmentForCell(target);
+            return;
+        }
+        if (target.tagName === 'BR-TABLE-ROW') {
+            this.rowCells.get(target)?.forEach((cell) => {
+                this.updateAlignmentForCell(cell);
+            });
+            return;
+        }
+        this.updateAllCellAlignments();
+    }
+    updateOverflowForTarget(target) {
+        if (target === null || !this.el.contains(target))
+            return;
+        if (target.tagName === 'BR-TABLE-CELL' || target.tagName === 'BR-TABLE-HEADER-CELL') {
+            this.updateOverflowForCell(target);
+            return;
+        }
+        if (target.tagName === 'BR-TABLE-ROW') {
+            this.rowCells.get(target)?.forEach((cell) => {
+                this.updateOverflowForCell(cell);
+            });
+            return;
+        }
+        this.updateAllCellOverflow();
+    }
+    /**
+     * Atualiza os tokens de overflow para uma célula específica, controlando o comportamento de overflow, text-overflow e white-space com base na resolução do token de overflow para a célula, que considera atributos específicos da célula, da linha, da coluna e da tabela para determinar o comportamento final de overflow a ser aplicado.
+     * @param cell A célula para a qual os tokens de overflow devem ser atualizados.
+     */
+    updateOverflowForCell(cell) {
+        const mode = this.resolveOverflowForCell(cell);
+        const config = TABLE_OVERFLOW_MAP[mode];
+        cell.style.setProperty(TABLE_TOKENS.CELL_OVERFLOW, config.overflow);
+        cell.style.setProperty(TABLE_TOKENS.CELL_TEXT_OVERFLOW, config.textOverflow);
+        cell.style.setProperty(TABLE_TOKENS.CELL_WHITE_SPACE, config.whiteSpace);
+        // O atributo 'applied-overflow' deve sempre aparecer
+        cell.setAttribute('data-applied-overflow', mode);
+    }
+    /**
+     * Resolve o token de overflow para uma célula específica, considerando a hierarquia de atributos (célula, linha, coluna, tabela) para determinar o comportamento de overflow final a ser aplicado à célula.
+     * @param cell A célula para a qual o token de overflow deve ser resolvido.
+     * @returns O valor do token de overflow resolvido para a célula, determinando o comportamento de overflow a ser aplicado.
+     */
+    resolveOverflowForCell(cell) {
+        // Resolução hierárquica: célula > linha > coluna > tabela > fallback
+        let value = cell.getAttribute('overflow');
+        if (value === null) {
+            const row = cell.closest('br-table-row');
+            value = row?.getAttribute('overflow') ?? null;
+        }
+        if (value === null) {
+            value = this.getColumnAttribute(cell, 'overflow') ?? null;
+        }
+        if (value === null) {
+            value = this.overflow ?? null;
+        }
+        if (value === null) {
+            value = TABLE_OVERFLOW.WRAP;
+        }
+        return value === TABLE_OVERFLOW.TRUNCATE ? TABLE_OVERFLOW.TRUNCATE : TABLE_OVERFLOW.WRAP;
+    }
+    /**
+     * Obtém o valor de um atributo específico de uma coluna para uma célula, permitindo a herança de propriedades da coluna para as células associadas com base no cabeçalho correspondente.
+     * @param cell A célula para a qual o atributo da coluna deve ser obtido.
+     * @param attribute O atributo específico a ser obtido da coluna (por exemplo, 'horizontal-alignment' ou 'vertical-alignment').
+     * @returns O valor do atributo da coluna correspondente à célula, ou null se não estiver definido.
+     */
+    getColumnAttribute(cell, attribute) {
+        const header = this.getHeaderForCell(cell);
+        return header?.getAttribute(attribute) ?? null;
+    }
+    /**
+     * Obtém o elemento de cabeçalho correspondente a uma célula específica, permitindo a associação entre células e seus respectivos cabeçalhos para herança de propriedades como alinhamento e largura.
+     * @param cell A célula para a qual o cabeçalho correspondente deve ser obtido.
+     * @returns O elemento de cabeçalho correspondente à célula, ou null se não for encontrado.
+     */
+    getHeaderForCell(cell) {
+        const index = this.getColumnIndex(cell);
+        if (index === -1)
+            return null;
+        const headers = this.getHeaderCells();
+        return headers[index] ?? null;
+    }
+    /**
+     * Resolve e aplica o token de densidade.
+     */
+    applyDensity() {
+        const resolved = resolveTokenValue(this.density, {
+            fallback: TABLE_DENSITY_MAP[TABLE_DENSITY.MEDIUM],
+            semanticMap: TABLE_DENSITY_MAP,
+        });
+        this.el.style.setProperty(TABLE_TOKENS.DENSITY, resolved);
+    }
+    /**
+     * Resolve e aplica os tokens relacionados aos divisores
+     * (estilo e fatores de linha/coluna).
+     */
+    applyDividers() {
+        const style = resolveTokenValue(this.dividerStyle, {
+            fallback: TABLE_DIVIDER_STYLE_MAP[TABLE_DIVIDER_STYLE.SOLID],
+            semanticMap: TABLE_DIVIDER_STYLE_MAP,
+        });
+        const rowFactor = (this.rowDivider ?? this.hasRowDivider) ? '1' : '0';
+        const columnFactor = (this.columnDivider ?? this.hasColumnDivider) ? '1' : '0';
+        this.el.style.setProperty(TABLE_TOKENS.DIVIDER_STYLE, style);
+        this.el.style.setProperty(TABLE_TOKENS.ROW_DIVIDER_FACTOR, rowFactor);
+        this.el.style.setProperty(TABLE_TOKENS.COLUMN_DIVIDER_FACTOR, columnFactor);
+    }
+    /**
+     * Retorna o mapa de classes base do componente.
+     *
+     * @returns Um objeto representando as classes CSS a serem aplicadas ao elemento da tabela.
+     */
+    getTableCssClassMap() {
+        return {
+            'br-table': true,
+        };
+    }
+    /**
+     * Renderiza a estrutura interna da tabela (header e body).
+     *
+     * @returns JSX.Element representando o conteúdo da tabela, incluindo os slots para header e body.
+     */
+    renderContent() {
+        return (h("div", { class: { 'br-table-content': true, loading: this.loading }, part: "content" }, h("slot", { name: "header", onSlotchange: this.handleStructureChange }), h("slot", { name: "body", onSlotchange: this.handleStructureChange })));
+    }
+    /**
+     * Renderiza o host do componente.
+     *
+     * @returns JSX.Element representando o elemento host do componente, contendo a estrutura da tabela.
+     */
+    render() {
+        return (h(Host, { key: 'bb33a9d7d47cbf531c23216f37e14114b2855db3', role: "table", "aria-busy": this.loading ? 'true' : null }, h("div", { key: '1e4c88e462a941eae79b2d7893721f0058dab307', class: this.getTableCssClassMap(), part: "container" }, this.renderContent(), this.loading ? (h("div", { part: "loading", role: "status", "aria-live": "polite" }, h("slot", { name: "loading" }, h("br-loading", { size: "small", label: "Carregando dados" })))) : null)));
+    }
+    static get is() { return "br-table"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["table.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["table.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "columnWidth": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "ColumnWidth",
+                    "resolved": "\"content\" | \"fill\" | `${number}fr` | `${number}px`",
+                    "references": {
+                        "ColumnWidth": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::ColumnWidth",
+                            "referenceLocation": "ColumnWidth"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- fill\n- content\n- ${number}px\n- ${number}fr\n\nObserva\u00E7\u00E3o:\n- `columnWidth` n\u00E3o define o comportamento de `overflow`, mas pode interferir na sua percep\u00E7\u00E3o ao alterar o espa\u00E7o dispon\u00EDvel da coluna.\n- `content` (`max-content`) tende a expandir a coluna e reduzir casos vis\u00EDveis de truncagem.\n- `fill` (`1fr`) tende a evidenciar truncagem quando o espa\u00E7o horizontal \u00E9 insuficiente."
+                        }, {
+                            "name": "default",
+                            "text": "fill"
+                        }],
+                    "text": "Largura global aplicada a todas as colunas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "column-width"
+            },
+            "density": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableDensity",
+                    "resolved": "\"large\" | \"medium\" | \"small\"",
+                    "references": {
+                        "TableDensity": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableDensity",
+                            "referenceLocation": "TableDensity"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Define a densidade visual do componente.\n\n- `small`: Alta densidade (componente menor, mais compacto e com menos espa\u00E7amento).\n- `medium`: Densidade intermedi\u00E1ria, padr\u00E3o recomendado para a maioria dos casos.\n- `large`: Baixa densidade (componente maior, mais espa\u00E7amento e altura)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "density"
+            },
+            "dividerStyle": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableDividerStyle",
+                    "resolved": "\"dashed\" | \"solid\"",
+                    "references": {
+                        "TableDividerStyle": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableDividerStyle",
+                            "referenceLocation": "TableDividerStyle"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- solid\n- dashed"
+                        }, {
+                            "name": "default",
+                            "text": "solid"
+                        }],
+                    "text": "Define o estilo visual dos divisores."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "divider-style"
+            },
+            "hasColumnDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }, {
+                            "name": "deprecated",
+                            "text": "Use `columnDivider`."
+                        }],
+                    "text": "Ativa divisores verticais entre colunas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-column-divider",
+                "defaultValue": "false"
+            },
+            "columnDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Ativa divisores verticais. Quando informada, tem preced\u00EAncia sobre `hasColumnDivider`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "column-divider"
+            },
+            "hasRowDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }, {
+                            "name": "deprecated",
+                            "text": "Use `rowDivider`."
+                        }],
+                    "text": "Ativa divisores horizontais entre linhas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-row-divider",
+                "defaultValue": "false"
+            },
+            "rowDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Ativa divisores horizontais. Quando informada, tem preced\u00EAncia sobre `hasRowDivider`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "row-divider"
+            },
+            "horizontalAlignment": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableAlignment",
+                    "resolved": "\"center\" | \"end\" | \"start\"",
+                    "references": {
+                        "TableAlignment": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableAlignment",
+                            "referenceLocation": "TableAlignment"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- start\n- center\n- end"
+                        }, {
+                            "name": "default",
+                            "text": "start"
+                        }],
+                    "text": "Define o alinhamento horizontal do conte\u00FAdo das c\u00E9lulas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "horizontal-alignment"
+            },
+            "verticalAlignment": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableAlignment",
+                    "resolved": "\"center\" | \"end\" | \"start\"",
+                    "references": {
+                        "TableAlignment": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableAlignment",
+                            "referenceLocation": "TableAlignment"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- start\n- center\n- end"
+                        }, {
+                            "name": "default",
+                            "text": "start"
+                        }],
+                    "text": "Define o alinhamento vertical do conte\u00FAdo das c\u00E9lulas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "vertical-alignment"
+            },
+            "overflow": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableOverflow",
+                    "resolved": "\"truncate\" | \"wrap\"",
+                    "references": {
+                        "TableOverflow": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableOverflow",
+                            "referenceLocation": "TableOverflow"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- truncate\n- wrap\n\nObserva\u00E7\u00E3o:\n- O overflow \u00E9 independente de `columnWidth`.\n- Com `columnWidth=\"content\"`, a coluna tende a crescer com o conte\u00FAdo (`max-content`), o que pode reduzir casos vis\u00EDveis de truncagem.\n- Com `columnWidth=\"fill\"`, a coluna ocupa o espa\u00E7o dispon\u00EDvel (`1fr`), ent\u00E3o a truncagem tende a ficar mais evidente quando n\u00E3o h\u00E1 espa\u00E7o suficiente."
+                        }, {
+                            "name": "default",
+                            "text": "wrap"
+                        }],
+                    "text": "Define o comportamento de overflow para as c\u00E9lulas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "overflow",
+                "defaultValue": "'wrap'"
+            },
+            "tooltipState": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableTooltipState",
+                    "resolved": "\"danger\" | \"info\" | \"success\" | \"warning\"",
+                    "references": {
+                        "TableTooltipState": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableTooltipState",
+                            "referenceLocation": "TableTooltipState"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- info\n- warning\n- danger\n- success"
+                        }, {
+                            "name": "default",
+                            "text": "info"
+                        }],
+                    "text": "Define o estado sem\u00E2ntico do tooltip nas c\u00E9lulas da tabela."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "tooltip-state",
+                "defaultValue": "'info'"
+            },
+            "tooltipMode": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableTooltipMode",
+                    "resolved": "\"disabled\" | \"enabled\" | \"inherit\"",
+                    "references": {
+                        "TableTooltipMode": {
+                            "location": "import",
+                            "path": "./table-types",
+                            "id": "src/components/table/table-types.ts::TableTooltipMode",
+                            "referenceLocation": "TableTooltipMode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Valores aceitos:\n- inherit\n- enabled\n- disabled"
+                        }, {
+                            "name": "default",
+                            "text": "disabled (valor efetivo)"
+                        }],
+                    "text": "Define o modo de resolu\u00E7\u00E3o do tooltip nas c\u00E9lulas da tabela."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "tooltip-mode"
+            },
+            "loading": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Indica que as linhas est\u00E3o sendo atualizadas pelo consumidor.\nO componente mant\u00E9m o conte\u00FAdo anterior, aplica `aria-busy=\"true\"` e\nexibe o slot `loading` sobre os dados; transporte, erro e substitui\u00E7\u00E3o das\nlinhas ficam sob responsabilidade da aplica\u00E7\u00E3o.\nA prop pode ser alterada diretamente ou pelos m\u00E9todos `startLoading()` e\n`stopLoading()`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "loading",
+                "defaultValue": "false"
+            }
+        };
+    }
+    static get methods() {
+        return {
+            "startLoading": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Inicia o estado de carregamento da tabela.",
+                    "tags": []
+                }
+            },
+            "stopLoading": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Interrompe o estado de carregamento da tabela.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "columnWidth",
+                "methodName": "handleTableColumnWidthChange"
+            }, {
+                "propName": "density",
+                "methodName": "handleDensityChange"
+            }, {
+                "propName": "hasColumnDivider",
+                "methodName": "handleDividerChange"
+            }, {
+                "propName": "hasRowDivider",
+                "methodName": "handleDividerChange"
+            }, {
+                "propName": "columnDivider",
+                "methodName": "handleDividerChange"
+            }, {
+                "propName": "rowDivider",
+                "methodName": "handleDividerChange"
+            }, {
+                "propName": "dividerStyle",
+                "methodName": "handleDividerChange"
+            }, {
+                "propName": "horizontalAlignment",
+                "methodName": "handleAlignmentChange"
+            }, {
+                "propName": "verticalAlignment",
+                "methodName": "handleAlignmentChange"
+            }, {
+                "propName": "overflow",
+                "methodName": "handleOverflowChange"
+            }];
+    }
+}