@govbr-ds/webcomponents 2.5.0 → 2.6.0

package/dist/esm/table.utils-CtVdlcgI.js

@@ -0,0 +1,706 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { F as FOCUSABLE_SELECTORS } from './focus-CNwZRgyL.js';
+
+/**
+ * Valores semânticos, mapas CSS e atributos internos da tabela.
+ *
+ * @module table-constants
+ * @remarks Este arquivo não mantém estado nem executa efeitos colaterais.
+ */
+/**
+ * Valores semânticos aceitos para largura de coluna.
+ */
+const COLUMN_WIDTH_SEMANTICS = {
+    FILL: 'fill',
+    CONTENT: 'content',
+};
+const COLUMN_WIDTH_MAP = {
+    [COLUMN_WIDTH_SEMANTICS.FILL]: '1fr',
+    [COLUMN_WIDTH_SEMANTICS.CONTENT]: 'max-content',
+};
+/**
+ * Densidades visuais aceitas pela tabela.
+ */
+const TABLE_DENSITY = {
+    SMALL: 'small',
+    MEDIUM: 'medium',
+    LARGE: 'large',
+};
+const TABLE_DENSITY_MAP = {
+    [TABLE_DENSITY.SMALL]: '8px',
+    [TABLE_DENSITY.MEDIUM]: '16px',
+    [TABLE_DENSITY.LARGE]: '24px',
+};
+const TABLE_BAR_PADDING_MAP = {
+    [TABLE_DENSITY.SMALL]: 'var(--spacing-scale-base) var(--spacing-scale-2x)',
+    [TABLE_DENSITY.MEDIUM]: 'var(--spacing-scale-2x) var(--spacing-scale-2x)',
+    [TABLE_DENSITY.LARGE]: 'var(--spacing-scale-3x) var(--spacing-scale-2x)',
+};
+/**
+ * Alinhamentos semânticos aceitos nos dois eixos.
+ */
+const TABLE_ALIGNMENT = {
+    START: 'start',
+    CENTER: 'center',
+    END: 'end',
+};
+const TABLE_ALIGNMENT_MAP = {
+    [TABLE_ALIGNMENT.START]: 'flex-start',
+    [TABLE_ALIGNMENT.CENTER]: 'center',
+    [TABLE_ALIGNMENT.END]: 'flex-end',
+};
+/**
+ * Estilos disponíveis para divisores de linha e coluna.
+ */
+const TABLE_DIVIDER_STYLE = {
+    SOLID: 'solid',
+    DASHED: 'dashed',
+};
+const TABLE_DIVIDER_STYLE_MAP = {
+    [TABLE_DIVIDER_STYLE.SOLID]: 'solid',
+    [TABLE_DIVIDER_STYLE.DASHED]: 'dashed',
+};
+const TABLE_CELL_OVERFLOW = {
+    HIDDEN: 'hidden',
+    VISIBLE: 'visible',
+};
+const TABLE_CELL_TEXT_OVERFLOW = {
+    ELLIPSIS: 'ellipsis',
+    CLIP: 'clip',
+};
+const TABLE_CELL_WHITE_SPACE = {
+    NOWRAP: 'nowrap',
+    NORMAL: 'normal',
+};
+/**
+ * Modos disponíveis para tratamento de overflow.
+ */
+const TABLE_OVERFLOW = {
+    TRUNCATE: 'truncate',
+    WRAP: 'wrap',
+};
+/**
+ * Estados visuais aceitos pelos tooltips das células.
+ */
+const TABLE_TOOLTIP_STATE = {
+    INFO: 'info',
+    DANGER: 'danger'};
+/**
+ * Modos de ativação e herança dos tooltips.
+ */
+const TABLE_TOOLTIP_MODE = {
+    INHERIT: 'inherit',
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+const TABLE_OVERFLOW_MAP = {
+    [TABLE_OVERFLOW.TRUNCATE]: {
+        overflow: TABLE_CELL_OVERFLOW.HIDDEN,
+        textOverflow: TABLE_CELL_TEXT_OVERFLOW.ELLIPSIS,
+        whiteSpace: TABLE_CELL_WHITE_SPACE.NOWRAP,
+    },
+    [TABLE_OVERFLOW.WRAP]: {
+        overflow: TABLE_CELL_OVERFLOW.VISIBLE,
+        textOverflow: TABLE_CELL_TEXT_OVERFLOW.CLIP,
+        whiteSpace: TABLE_CELL_WHITE_SPACE.NORMAL,
+    },
+};
+/**
+ * Largura fixa reservada à coluna de seleção.
+ */
+const TABLE_SELECTION_COLUMN_WIDTH = '48px';
+const TABLE_SELECTION_COLUMN_ATTR = 'data-selection-column';
+const TABLE_SELECTION_GENERATED_ATTR = 'data-generated-selection';
+const TABLE_SELECTION_CHECKBOX_ATTR = 'data-selection-checkbox';
+/**
+ * Configurações possíveis para a expansão específica de uma linha.
+ */
+const TABLE_ROW_EXPANSION = {
+    INHERIT: 'inherit',
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+/**
+ * Largura fixa reservada à coluna de expansão.
+ */
+const TABLE_EXPANSION_COLUMN_WIDTH = '56px';
+const TABLE_EXPANSION_COLUMN_ATTR = 'data-expansion-column';
+const TABLE_EXPANSION_GENERATED_ATTR = 'data-generated-expansion';
+const TABLE_EXPANSION_ACTION_ATTR = 'data-row-expansion-action';
+/** Modos de ordenação suportados pela tabela. */
+const TABLE_SORT_MODE = {
+    SINGLE: 'single',
+    MULTI: 'multi',
+};
+/** Estratégias de aplicação da ordenação. */
+const TABLE_SORT_STRATEGY = {
+    LOCAL: 'local',
+    MANUAL: 'manual',
+};
+/** Direções de ordenação suportadas por uma coluna. */
+const TABLE_SORT_DIRECTION = {
+    ASC: 'asc',
+    DESC: 'desc',
+};
+
+/** Entradas inválidas seguem o comportamento de uma célula simples. */
+function resolveTableSpan(value) {
+    const span = Number(value);
+    return Number.isInteger(span) && span > 0 && span <= 1000 ? span : 1;
+}
+/** Posiciona células omitidas por mesclas, sem depender da posição no array da linha. */
+function getTablePlacements(rows, selector) {
+    const occupied = rows.map(() => []);
+    const placements = [];
+    rows.forEach((row, rowIndex) => {
+        let column = 0;
+        Array.from(row.children)
+            .filter((cell) => cell.matches(selector))
+            .forEach((cell) => {
+            const rowSpan = Math.min(resolveTableSpan(cell.getAttribute('row-span')), rows.length - rowIndex);
+            const colSpan = resolveTableSpan(cell.getAttribute('col-span'));
+            while (Array.from({ length: colSpan }, (_, offset) => occupied[rowIndex][column + offset]).some(Boolean))
+                column++;
+            placements.push({ cell: cell, row: rowIndex, column, rowSpan, colSpan });
+            for (let y = rowIndex; y < rowIndex + rowSpan; y++) {
+                for (let x = column; x < column + colSpan; x++)
+                    occupied[y][x] = true;
+            }
+            column += colSpan;
+        });
+    });
+    return placements;
+}
+/** Colunas finais, incluindo folhas que atravessam níveis do cabeçalho. */
+function getTableLeafHeaders(rows) {
+    const columns = [];
+    for (const placement of getTablePlacements(rows, 'br-table-header-cell')) {
+        for (let index = placement.column; index < placement.column + placement.colSpan; index++) {
+            columns[index] = placement.cell;
+        }
+    }
+    return columns;
+}
+/** Um grupo é uma sequência contígua com a mesma chave; linhas sem chave são unidades independentes. */
+function getTableRowGroups(rows) {
+    const groups = [];
+    let previousKey;
+    for (const row of rows) {
+        const key = row.getAttribute('row-group')?.trim() || undefined;
+        if (key !== undefined && key === previousKey)
+            groups[groups.length - 1].push(row);
+        else
+            groups.push([row]);
+        previousKey = key;
+    }
+    return groups;
+}
+/** Amplia uma faixa sem separar células mescladas ou linhas de um mesmo grupo. */
+function expandTableGroupRange(rows, start, end) {
+    const firstKey = rows[start]?.getAttribute('row-group')?.trim();
+    const lastKey = rows[end - 1]?.getAttribute('row-group')?.trim();
+    while (firstKey && start > 0 && rows[start - 1].getAttribute('row-group')?.trim() === firstKey)
+        start--;
+    while (lastKey && end < rows.length && rows[end].getAttribute('row-group')?.trim() === lastKey)
+        end++;
+    return { start, end };
+}
+/** Escreve apenas tokens internos e ARIA; não modifica props públicas do consumidor. */
+function applyTablePlacements(placements) {
+    for (const { cell, row, column, rowSpan, colSpan } of placements) {
+        const firstRow = row + 1;
+        const lastRow = row + rowSpan + 1;
+        cell.style.setProperty('--table-cell-grid-column', `${column + 1} / span ${colSpan}`);
+        cell.style.setProperty('--table-cell-grid-row', `${firstRow} / ${lastRow}`);
+        cell.setAttribute('aria-colindex', String(column + 1));
+        if (colSpan > 1)
+            cell.setAttribute('aria-colspan', String(colSpan));
+        else
+            cell.removeAttribute('aria-colspan');
+        if (rowSpan > 1)
+            cell.setAttribute('aria-rowspan', String(rowSpan));
+        else
+            cell.removeAttribute('aria-rowspan');
+    }
+}
+/** Configura a grade multinível e estende as colunas geradas até o último nível. */
+function applyTableHeaderLayout(header) {
+    const rows = Array.from(header?.querySelectorAll(':scope > br-table-row') ?? []);
+    header?.toggleAttribute('data-multilevel', rows.length > 1);
+    rows[0]
+        ?.querySelectorAll(`[${TABLE_SELECTION_GENERATED_ATTR}], [${TABLE_EXPANSION_GENERATED_ATTR}]`)
+        .forEach((cell) => {
+        if (cell.getAttribute('row-span') !== String(rows.length))
+            cell.setAttribute('row-span', String(rows.length));
+    });
+    applyTablePlacements(getTablePlacements(rows, 'br-table-header-cell'));
+}
+
+const CELL_SELECTOR = 'br-table-cell, br-table-header-cell';
+const CONTROL_SELECTOR = `${FOCUSABLE_SELECTORS}, br-checkbox, br-table-action, [contenteditable="true"], summary`;
+/** Coordena apenas o DOM pertencente à célula, sem acessar internals de controles. */
+class TableCellKeyboard {
+    constructor(host, surface) {
+        this.host = host;
+        this.surface = surface;
+        this.originalTabIndexes = new Map();
+        this.active = false;
+        this.hasGridControls = false;
+    }
+    connect() {
+        this.observer?.disconnect();
+        if (this.host.closest('br-table') === null)
+            return;
+        this.observer = new MutationObserver(() => {
+            this.sync();
+            this.notifyFocusRegistration();
+        });
+        const options = {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            attributeFilter: ['disabled', 'hidden', 'tabindex', 'sortable'],
+        };
+        this.observer.observe(this.host, options);
+        if (this.host.shadowRoot !== null)
+            this.observer.observe(this.host.shadowRoot, options);
+        this.notifyFocusRegistration();
+        this.sync();
+    }
+    disconnect() {
+        this.observer?.disconnect();
+        this.surface.removeAttribute('tabindex');
+        this.originalTabIndexes.forEach((value, element) => {
+            this.restoreTabIndex(element, value);
+        });
+        this.originalTabIndexes.clear();
+    }
+    candidates() {
+        const roots = [this.host];
+        if (this.host.shadowRoot !== null)
+            roots.push(this.host.shadowRoot);
+        const candidates = roots.flatMap((root) => Array.from(root.querySelectorAll(CONTROL_SELECTOR)).filter((control) => control !== this.surface &&
+            !control.matches(CELL_SELECTOR) &&
+            control.closest(CELL_SELECTOR) === (root === this.host ? this.host : null)));
+        return [...new Set([...candidates, ...this.originalTabIndexes.keys()])].filter((control) => control.closest(CELL_SELECTOR) === this.host ||
+            (control.getRootNode() === this.host.shadowRoot && control.closest(CELL_SELECTOR) === null));
+    }
+    controls() {
+        return this.candidates().filter((control) => !control.matches(':disabled, [disabled], [hidden], [inert]') &&
+            control.closest('[hidden], [inert], [disabled]') === null &&
+            control.getClientRects().length > 0 &&
+            getComputedStyle(control).visibility !== 'hidden' &&
+            this.originalTabIndexes.get(control) !== '-1' &&
+            !this.candidates().some((parent) => parent !== control && parent.contains(control)));
+    }
+    sync() {
+        const candidates = this.candidates();
+        this.originalTabIndexes.forEach((value, control) => {
+            if (candidates.includes(control))
+                return;
+            this.restoreTabIndex(control, value);
+            this.originalTabIndexes.delete(control);
+        });
+        candidates.forEach((control) => {
+            if (!this.originalTabIndexes.has(control)) {
+                this.originalTabIndexes.set(control, control.getAttribute('tabindex'));
+            }
+            const value = this.originalTabIndexes.get(control);
+            if (value === null) {
+                if (control.hasAttribute('tabindex'))
+                    control.removeAttribute('tabindex');
+            }
+            else if (value !== undefined && control.getAttribute('tabindex') !== value) {
+                control.setAttribute('tabindex', value);
+            }
+        });
+        const tabIndex = this.active && !this.hasGridControls ? 0 : -1;
+        if (this.surface.getAttribute('tabindex') !== String(tabIndex))
+            this.surface.tabIndex = tabIndex;
+    }
+    restoreTabIndex(control, value) {
+        if (value === null)
+            control.removeAttribute('tabindex');
+        else
+            control.setAttribute('tabindex', value);
+    }
+    notifyFocusRegistration() {
+        this.host.dispatchEvent(new CustomEvent('brInternalTableCellFocus', {
+            bubbles: true,
+            composed: true,
+            detail: {
+                host: this.host,
+                surface: this.surface,
+                controls: () => this.controls(),
+                update: (active, hasGridControls) => {
+                    this.active = active;
+                    this.hasGridControls = hasGridControls;
+                    this.sync();
+                },
+            },
+        }));
+    }
+}
+/** Gerencia a célula ativa e os dois modos de teclado de uma instância da grade. */
+class TableKeyboardController {
+    constructor(host, getRows, reveal, pageSize) {
+        this.host = host;
+        this.getRows = getRows;
+        this.reveal = reveal;
+        this.pageSize = pageSize;
+        this.cells = new Map();
+        this.interacting = false;
+        this.hasFocused = false;
+    }
+    register(cell) {
+        if (this.active?.host === cell.host)
+            this.active = cell;
+        this.cells.set(cell.host, cell);
+        this.sync();
+        if (this.pendingFocus === cell.host) {
+            // A linha ancestral também precisa terminar a hidratação antes de receber foco.
+            if (this.focusFrame !== undefined)
+                cancelAnimationFrame(this.focusFrame);
+            this.focusFrame = requestAnimationFrame(() => {
+                this.focusFrame = undefined;
+                this.focusPendingCell();
+            });
+        }
+    }
+    sync() {
+        const logicalCells = this.getRows().flat();
+        this.cells.forEach((cell, host) => {
+            if (!logicalCells.includes(host))
+                this.cells.delete(cell.host);
+        });
+        const available = logicalCells.filter((cell) => this.cells.has(cell) && cell.isConnected);
+        if (!this.hasFocused || this.active === undefined || !available.includes(this.active.host)) {
+            this.active = this.cells.get(available[0]);
+            this.interacting = false;
+        }
+        const hasGridControls = available.some((host) => this.cells.get(host)?.controls().length);
+        this.cells.forEach((cell) => {
+            cell.update(cell === this.active, Boolean(hasGridControls));
+        });
+    }
+    disconnect() {
+        if (this.focusFrame !== undefined)
+            cancelAnimationFrame(this.focusFrame);
+        this.focusFrame = undefined;
+        this.cells.clear();
+        this.active = undefined;
+        this.interacting = false;
+        this.hasFocused = false;
+        this.pendingFocus = undefined;
+        this.releaseTransitionFocus();
+    }
+    focusIn(event) {
+        const cell = this.cellFromEvent(event);
+        if (event.composedPath()[0] !== this.host && this.transitionTabIndex !== undefined) {
+            this.pendingFocus = undefined;
+            this.releaseTransitionFocus();
+        }
+        if (cell === undefined)
+            return;
+        this.active = cell;
+        this.hasFocused = true;
+        this.interacting = event.composedPath()[0] !== cell.surface;
+        this.sync();
+    }
+    focusOut(event) {
+        if (event.relatedTarget instanceof Node && this.host.contains(event.relatedTarget))
+            return;
+        if (event.relatedTarget !== null || event.composedPath()[0] === this.host) {
+            this.pendingFocus = undefined;
+            this.releaseTransitionFocus();
+        }
+        this.interacting = false;
+        this.sync();
+    }
+    keyDown(event) {
+        if (event.defaultPrevented || event.altKey || event.metaKey)
+            return;
+        if (this.pendingFocus !== undefined && event.composedPath()[0] === this.host) {
+            if (event.key === 'Tab') {
+                this.abandonPendingFocus(event.shiftKey);
+                return;
+            }
+            this.navigate(event, this.pendingFocus);
+            return;
+        }
+        const cell = this.cellFromEvent(event);
+        if (cell === undefined)
+            return;
+        if (this.interacting) {
+            this.handleInteraction(event, cell);
+            return;
+        }
+        if (event.key === 'Enter' || event.key === 'F2') {
+            const control = cell.controls()[0];
+            if (control !== undefined) {
+                event.preventDefault();
+                this.interacting = true;
+                this.sync();
+                control.focus();
+            }
+            return;
+        }
+        this.navigate(event, cell.host);
+    }
+    handleInteraction(event, cell) {
+        if (event.key === 'Escape' || event.key === 'F2') {
+            event.preventDefault();
+            this.interacting = false;
+            this.sync();
+            cell.surface.focus();
+        }
+    }
+    navigate(event, host) {
+        const rows = this.getRows();
+        const rowIndex = rows.findIndex((row) => row.includes(host));
+        const columnIndex = rows[rowIndex]?.indexOf(host) ?? -1;
+        if (rowIndex < 0 || columnIndex < 0)
+            return;
+        let nextRow = rowIndex;
+        let nextColumn = columnIndex;
+        switch (event.key) {
+            case 'ArrowRight':
+                nextColumn++;
+                break;
+            case 'ArrowLeft':
+                nextColumn--;
+                break;
+            case 'ArrowDown':
+                nextRow++;
+                break;
+            case 'ArrowUp':
+                nextRow--;
+                break;
+            case 'Home':
+                if (event.ctrlKey)
+                    nextRow = 0;
+                nextColumn = 0;
+                break;
+            case 'End':
+                if (event.ctrlKey)
+                    nextRow = rows.length - 1;
+                nextColumn = (rows[nextRow]?.length ?? 1) - 1;
+                break;
+            case 'PageDown':
+            case 'PageUp': {
+                const pageSize = this.pageSize();
+                nextRow += event.key === 'PageDown' ? pageSize : -pageSize;
+                break;
+            }
+            default:
+                return;
+        }
+        [nextRow, nextColumn] = this.skipMergedCell(event.key, rows, host, rowIndex, columnIndex, nextRow, nextColumn);
+        event.preventDefault();
+        nextRow = Math.max(0, Math.min(nextRow, rows.length - 1));
+        nextColumn = Math.max(0, Math.min(nextColumn, rows[nextRow].length - 1));
+        const target = rows[nextRow][nextColumn];
+        this.pendingFocus = target;
+        this.reveal(target);
+        this.focusPendingCell();
+        if (this.pendingFocus !== undefined) {
+            // Mantém as próximas teclas na grade enquanto a linha de destino hidrata.
+            if (this.transitionTabIndex === undefined)
+                this.transitionTabIndex = this.host.getAttribute('tabindex');
+            this.host.tabIndex = -1;
+            this.host.focus({ preventScroll: true });
+        }
+    }
+    skipMergedCell(key, rows, host, row, column, nextRow, nextColumn) {
+        if (!key.startsWith('Arrow'))
+            return [nextRow, nextColumn];
+        const rowStep = nextRow - row;
+        const columnStep = nextColumn - column;
+        while (rows[nextRow]?.[nextColumn] === host) {
+            nextRow += rowStep;
+            nextColumn += columnStep;
+        }
+        return [nextRow, nextColumn];
+    }
+    abandonPendingFocus(shift) {
+        this.pendingFocus = undefined;
+        if (this.focusFrame !== undefined)
+            cancelAnimationFrame(this.focusFrame);
+        this.focusFrame = undefined;
+        if (!shift) {
+            this.cells.forEach((cell) => {
+                cell.update(false, false);
+            });
+            const scroller = this.host.shadowRoot?.querySelector('.br-table-scroll');
+            if (scroller && !scroller.hasAttribute('tabindex')) {
+                scroller.tabIndex = -1;
+                this.scrollerTabIndexSet = scroller;
+            }
+        }
+    }
+    releaseTransitionFocus() {
+        if (this.scrollerTabIndexSet !== undefined) {
+            this.scrollerTabIndexSet.removeAttribute('tabindex');
+            this.scrollerTabIndexSet = undefined;
+        }
+        if (this.transitionTabIndex === undefined)
+            return;
+        const tabIndex = this.transitionTabIndex;
+        this.transitionTabIndex = undefined;
+        if (tabIndex === null)
+            this.host.removeAttribute('tabindex');
+        else
+            this.host.setAttribute('tabindex', tabIndex);
+    }
+    focusPendingCell() {
+        if (this.pendingFocus === undefined)
+            return;
+        const next = this.cells.get(this.pendingFocus);
+        if (next === undefined || !next.host.isConnected)
+            return;
+        if (getComputedStyle(next.surface).visibility === 'hidden')
+            return;
+        this.pendingFocus = undefined;
+        this.active = next;
+        this.sync();
+        next.surface.focus();
+        this.releaseTransitionFocus();
+    }
+    cellFromEvent(event) {
+        const host = event.composedPath().find((target) => target instanceof HTMLElement && target.matches(CELL_SELECTOR));
+        return host instanceof HTMLElement ? this.cells.get(host) : undefined;
+    }
+}
+
+/** Mantém os indicadores de conteúdo oculto sincronizados com a área rolável. */
+class TableScrollShadows {
+    constructor(viewport, content, shell) {
+        this.viewport = viewport;
+        this.shell = shell;
+        /** Recalcula as bordas, tolerando arredondamento de pixels nas extremidades. */
+        this.update = () => {
+            const { scrollTop, scrollLeft, scrollHeight, scrollWidth, clientHeight, clientWidth } = this.viewport;
+            const directions = {
+                top: scrollTop > 1,
+                bottom: scrollHeight - clientHeight - scrollTop > 1,
+                left: scrollLeft > 1,
+                right: scrollWidth - clientWidth - scrollLeft > 1,
+            };
+            for (const [direction, visible] of Object.entries(directions)) {
+                this.shell.style.setProperty(`--table-scroll-shadow-${direction}`, visible ? '8px' : '0px');
+            }
+        };
+        viewport.addEventListener('scroll', this.update, { passive: true });
+        if (typeof ResizeObserver !== 'undefined') {
+            this.observer = new ResizeObserver(this.update);
+            this.observer.observe(viewport);
+            this.observer.observe(content);
+        }
+        this.update();
+    }
+    /** Remove listeners e observadores ao desmontar a superfície. */
+    disconnect() {
+        this.viewport.removeEventListener('scroll', this.update);
+        this.observer?.disconnect();
+    }
+}
+
+/**
+ * Custom properties utilizadas para comunicar valores calculados aos componentes.
+ *
+ * @module table-tokens
+ */
+/**
+ * Nomes canônicos dos tokens CSS internos da tabela.
+ *
+ * @remarks Centralizar os nomes evita divergências entre TypeScript e SCSS.
+ */
+const TABLE_TOKENS = {
+    COLUMN_WIDTHS: '--br-table-column-widths',
+    DENSITY: '--br-table-density',
+    BAR_PADDING: '--br-table-bar-padding',
+    HORIZONTAL_ALIGNMENT: '--br-table-horizontal-alignment',
+    VERTICAL_ALIGNMENT: '--br-table-vertical-alignment',
+    DIVIDER_STYLE: '--br-table-divider-style',
+    COLUMN_DIVIDER_FACTOR: '--br-table-column-divider-factor',
+    ROW_DIVIDER_FACTOR: '--br-table-row-divider-factor',
+    CELL_OVERFLOW: '--br-table-cell-overflow',
+    CELL_TEXT_OVERFLOW: '--br-table-cell-text-overflow',
+    CELL_WHITE_SPACE: '--br-table-cell-white-space',
+    EXPANDED_CONTENT_HEIGHT: '--br-table-expanded-content-height',
+};
+
+/**
+ * Funções puras compartilhadas pela resolução de tokens da tabela.
+ *
+ * @module table-utils
+ */
+/**
+ * Resolve um valor semântico ou CSS validado, utilizando fallback quando inválido.
+ *
+ * @param raw Valor recebido pela API pública.
+ * @param options Mapa semântico, validadores e fallback da resolução.
+ * @returns Valor CSS seguro que pode ser aplicado ao componente.
+ */
+function resolveTokenValue(raw, options) {
+    if (raw === undefined || raw === '')
+        return options.fallback;
+    const { semanticMap, validators = [], fallback } = options;
+    if (semanticMap && raw in semanticMap) {
+        return semanticMap[raw];
+    }
+    const isValid = validators.some((validator) => validator(raw));
+    return isValid ? raw : fallback;
+}
+/**
+ * Valida valores positivos expressos em pixels.
+ *
+ * @param value Valor CSS candidato.
+ * @returns `true` quando o valor utiliza `px` e é maior que zero.
+ */
+const positivePxValidator = (value) => /^\d+(\.\d+)?px$/.test(value) && parseFloat(value) > 0;
+/**
+ * Valida valores positivos expressos como fração de grid.
+ *
+ * @param value Valor CSS candidato.
+ * @returns `true` quando o valor utiliza `fr` e é maior que zero.
+ */
+const positiveFrValidator = (value) => /^\d+(\.\d+)?fr$/.test(value) && parseFloat(value) > 0;
+/**
+ * Solicita a execução de uma função no próximo frame de animação.
+ *
+ * @returns Promise que resolve no próximo frame de animação.
+ */
+const requestAnimationFramePromise = () => new Promise((resolve) => {
+    requestAnimationFrame(() => resolve());
+});
+/**
+ * Resolve a densidade semântica correspondente ao token CSS efetivo de uma célula.
+ */
+function resolveTableDensityFromElement(element) {
+    if (element === null)
+        return TABLE_DENSITY.MEDIUM;
+    const computedDensity = getComputedStyle(element).getPropertyValue(TABLE_TOKENS.DENSITY).trim();
+    const resolvedDensity = Object.entries(TABLE_DENSITY_MAP).find(([, value]) => value === computedDensity)?.[0];
+    return resolvedDensity ?? TABLE_DENSITY.MEDIUM;
+}
+/**
+ * Indica se uma mutação de `class` apenas adicionou ou removeu a marca
+ * `hydrated` do Stencil, que não altera a herança de tokens da tabela.
+ * Exige `attributeOldValue` no observer.
+ */
+function isHydrationClassMutation(mutation) {
+    if (mutation.attributeName !== 'class')
+        return false;
+    const tokens = (value) => (value ?? '')
+        .split(/\s+/)
+        .filter((token) => token !== '' && token !== 'hydrated')
+        .sort()
+        .join(' ');
+    return tokens(mutation.oldValue) === tokens(mutation.target.getAttribute('class'));
+}
+
+export { COLUMN_WIDTH_SEMANTICS as A, TABLE_TOKENS as B, COLUMN_WIDTH_MAP as C, TABLE_ALIGNMENT_MAP as D, TABLE_OVERFLOW_MAP as E, TABLE_DENSITY as F, TABLE_DENSITY_MAP as G, TABLE_BAR_PADDING_MAP as H, TABLE_DIVIDER_STYLE_MAP as I, TABLE_DIVIDER_STYLE as J, positivePxValidator as K, positiveFrValidator as L, TABLE_TOOLTIP_MODE as M, requestAnimationFramePromise as N, TableCellKeyboard as O, TABLE_SELECTION_GENERATED_ATTR as T, getTableLeafHeaders as a, TABLE_EXPANSION_GENERATED_ATTR as b, getTablePlacements as c, applyTablePlacements as d, TABLE_EXPANSION_COLUMN_ATTR as e, TABLE_EXPANSION_COLUMN_WIDTH as f, getTableRowGroups as g, TABLE_ALIGNMENT as h, TABLE_EXPANSION_ACTION_ATTR as i, TABLE_ROW_EXPANSION as j, TABLE_SELECTION_CHECKBOX_ATTR as k, TABLE_SELECTION_COLUMN_ATTR as l, TABLE_SELECTION_COLUMN_WIDTH as m, expandTableGroupRange as n, TABLE_SORT_MODE as o, TABLE_SORT_STRATEGY as p, TABLE_OVERFLOW as q, resolveTableSpan as r, TABLE_TOOLTIP_STATE as s, TableKeyboardController as t, TableScrollShadows as u, resolveTokenValue as v, TABLE_SORT_DIRECTION as w, isHydrationClassMutation as x, resolveTableDensityFromElement as y, applyTableHeaderLayout as z };