@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/collection/components/cookiebar/cookiebar.js

@@ -0,0 +1,1419 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h, } from "@stencil/core";
+import { BREAKPOINTS, BreakpointObserver } from "../../shared/utils/breakpoint-observer";
+import { isEventTargetInside } from "../../shared/utils/event";
+import { generateUniqueId } from "../../shared/utils/id";
+import { supportsNativeModalDialog, syncNativeModalDialog } from "../../shared/utils/native-dialog";
+import { aggregateSelection } from "./cookiebar.utils";
+/**
+ * Componente de gestão de consentimento de cookies (LGPD), obrigatório em sites e aplicativos do
+ * Governo Federal que coletam dados de usuários.
+ *
+ * Apresenta duas etapas visuais:
+ * - **default** – barra inferior com texto informativo e botões de ação;
+ * - **open** – painel de tela cheia com lista de classes de cookies configuráveis.
+ *
+ * A persistência do consentimento é responsabilidade do consumidor: ouça o evento
+ * `brCookiebarAccept` e armazene o payload onde desejar (localStorage, cookie HTTP, API etc.).
+ *
+ * Para a documentação completa, consulte o [Design System do GovBR](https://www.gov.br/ds/components/cookiebar?tab=designer).
+ *
+ * @category Feedback
+ * @status stable
+ * @slot default - Recebe os subcomponentes `br-cookiebar-group`, `br-cookiebar-note-group` e `br-cookiebar-note`.
+ * @slot header - Recebe `br-cookiebar-header` ou HTML livre.
+ * @slot links - Recebe links complementares (`br-cookiebar-link` ou elementos `<a>` livres).
+ * @slot actions - Recebe botões de ação. Se vazio, o componente renderiza os botões padrão.
+ *
+ * @part container - Container raiz do componente.
+ * @part default-panel - Painel fechado (modo default).
+ * @part open-panel - Painel expandido (modo open).
+ * @part header - Cabeçalho do painel aberto.
+ * @part body - Corpo do painel aberto (com rolagem).
+ * @part footer - Rodapé com botões de ação.
+ * @part scrim - Camada de sobreposição opcional.
+ */
+export class Cookiebar {
+    constructor() {
+        /**
+         * Descrição do painel `open` espelhada no Shadow DOM para uso em `aria-describedby`.
+         * Derivada do `entryText` do `br-cookiebar-header` filho (quando presente).
+         * Necessária porque `aria-describedby` não cruza o limite shadow/light DOM.
+         */
+        this.openPanelDescription = '';
+        /** Indica se há conteúdo no slot `actions`. Controla a exibição da área de ações. */
+        this.hasActionsSlot = false;
+        /** Indica se há conteúdo no slot `header`. Controla a exibição da área de cabeçalho. */
+        this.hasHeaderSlot = false;
+        /** Indica se há conteúdo no slot `links`. Controla a exibição da área de links. */
+        this.hasLinksSlot = false;
+        /** Indica se o viewport está no breakpoint mobile (x-small, ≤575px). */
+        this.isMobile = false;
+        /**
+         * Texto anunciado pela região `aria-live` ao exibir o painel default.
+         * Mantido em elemento sr-only separado para não interferir com o foco do container.
+         */
+        this.openLiveAnnouncement = '';
+        /** Estado atual do checkbox "Selecionar tudo": `true`, `false` ou `'indeterminate'`. */
+        this.selectAllState = false;
+        /** Identificador único; gerado automaticamente quando omitido. */
+        this.customId = generateUniqueId();
+        /**
+         * Controla a visibilidade do componente.
+         * O consumidor é responsável por definir este valor com base na persistência do consentimento
+         * (ex: verificar se já existe um cookie de consentimento salvo).
+         */
+        this.show = false;
+        /**
+         * Estado visual atual do painel.
+         * - `default`: barra inferior com texto e botões.
+         * - `open`: painel de tela cheia com grupos de cookies configuráveis.
+         */
+        this.mode = 'default';
+        /**
+         * Define se o cookiebar opera no padrão opt-out (`true`, recomendado) ou opt-in (`false`).
+         * - **opt-out** (`true`): botão secundário "Definir Cookies"; usuário pode configurar cookies.
+         * - **opt-in** (`false`): botão secundário "Ver Política de Cookies"; painel é somente leitura.
+         */
+        this.allOptOut = true;
+        /** Texto do botão primário de aceite. Padrão: `Aceitar`. */
+        this.acceptButton = 'Aceitar';
+        /**
+         * Texto do botão de rejeição dos cookies não obrigatórios.
+         * Exibido apenas quando `show-reject-button="true"`.
+         */
+        this.rejectButton = 'Rejeitar não obrigatórios';
+        /**
+         * Quando `true`, exibe o botão "Rejeitar não obrigatórios" nos painéis default e open.
+         * Cookies de grupos com `group-opt-out="false"` (sempre ativos) não são afetados.
+         */
+        this.showRejectButton = false;
+        /** Texto do botão secundário quando `all-opt-out="true"`. */
+        this.optOutButton = 'Definir Cookies';
+        /** Texto do botão secundário quando `all-opt-out="false"`. */
+        this.optInButton = 'Ver Política de Cookies';
+        /**
+         * `aria-label` do botão fechar exibido no canto do painel expandido (`mode="open"`).
+         * Permite traduzir o rótulo para outros idiomas.
+         */
+        this.closeLabel = 'Fechar';
+        /**
+         * `aria-label` do painel expandido (`mode="open"`), que possui `role="dialog"`.
+         * Leitores de tela anunciam este texto ao entrar no diálogo modal de configuração de cookies.
+         * Deve descrever o propósito do diálogo de forma sucinta (ex: "Configurações de cookies").
+         */
+        this.panelLabel = 'Configurações de cookies';
+        /**
+         * `aria-label` da barra de aviso de cookies (`mode="default"`).
+         * Deve descrever o propósito da região de forma sucinta (ex: "Aviso de cookies").
+         */
+        this.defaultPanelLabel = 'Aviso de cookies';
+        /** Rótulo do título da seção de grupos de cookies. */
+        this.cookieGroupsLabel = 'Classes de cookies';
+        /**
+         * `aria-label` do elemento `<nav>` que envolve os links complementares no painel expandido.
+         * Permite traduzir o rótulo para outros idiomas.
+         */
+        this.linksLabel = 'Links complementares';
+        /**
+         * Estado inicial do checkbox "Selecionar tudo".
+         * Quando `true`, todos os grupos opt-out iniciam selecionados.
+         */
+        this.selectAll = false;
+        /** Texto do checkbox geral quando está totalmente selecionado (ação: desselecionar). */
+        this.selectAllLabel = 'Selecionar tudo';
+        /** Texto do checkbox geral quando está desmarcado ou indeterminado (ação: selecionar). */
+        this.unselectAllLabel = 'Desselecionar tudo';
+        /**
+         * Quando `true`, exibe uma camada semitransparente (scrim) sobre o conteúdo da página
+         * abaixo do painel default, sinalizando que o cookiebar requer atenção.
+         *
+         * **Efeito no foco:** com `scrim=true`, o atributo `inert` é aplicado nos irmãos do
+         * cookiebar no DOM, prendendo o foco e o cursor virtual do leitor de tela dentro do
+         * painel default enquanto ele estiver visível. Com `scrim=false` (padrão), nenhum trap
+         * é ativado — o usuário pode navegar livremente pela página, em conformidade com
+         * WCAG 2.1.2 (No Keyboard Trap). Use `scrim=true` apenas quando o cenário de negócio
+         * exigir que a decisão sobre cookies seja tomada antes de qualquer outra interação.
+         *
+         * No modo `open` (diálogo modal), o `inert` é aplicado independentemente do valor de `scrim`.
+         */
+        this.scrim = false;
+        /**
+         * Elemento focado na página antes do cookiebar aparecer.
+         * Restaurado quando o componente é ocultado (`show` → false).
+         * Referência: WCAG 2.4.3.
+         */
+        this.pageTriggerElement = null;
+        /**
+         * Elemento que disparou a abertura do painel `open` — restaurado ao fechar o diálogo.
+         * Referência: WCAG 2.4.3.
+         */
+        this.triggerElement = null;
+        /**
+         * Referência ao painel default — usada para mover o foco ao abrir no modo `default`.
+         */
+        this.defaultPanelRef = null;
+        /**
+         * Flag que sinaliza intenção de focar o painel default após o próximo render.
+         * Definida nos `@Watch` e consumida em `componentDidUpdate`, garantindo que
+         * `defaultPanelRef` já esteja disponível no DOM.
+         */
+        this.pendingFocusDefault = false;
+        /**
+         * Flag que sinaliza intenção de focar o botão fechar do painel `open` após o próximo render.
+         * Definida em `trapFocus()` e consumida em `componentDidUpdate`, garantindo que
+         * o botão fechar já esteja disponível no DOM antes de receber o foco.
+         */
+        this.pendingFocusOpen = false;
+        this.openAnnouncementFrame = null;
+        /** Instância do observador de breakpoint para detecção de mobile. */
+        this.breakpointObserver = null;
+        /**
+         * Lista de elementos que receberam `inert` ao abrir o painel.
+         * Armazenada para restaurar o estado original ao fechar.
+         */
+        this.inertedElements = [];
+        this.nativeDialogRef = null;
+        this.globalKeydownAttached = false;
+        this.slotChangeHandlers = new Map();
+        this.handleNativeCancel = (event) => {
+            event.preventDefault();
+            if (this.mode === 'open')
+                this.mode = 'default';
+        };
+        /** Atualiza `selectAllState` e propaga o novo valor para os grupos (sem emitir evento externo). */
+        this.handleSelectAllChange = (event) => {
+            const newValue = event.detail;
+            this.selectAllState = newValue;
+            this.propagateSelectAll(newValue);
+        };
+        /**
+         * Emite `brCookiebarAccept` (void) e em seguida `brCookiebarResponse` (payload completo),
+         * construído uma única vez, depois libera o trap de foco e oculta o componente.
+         */
+        this.handleAccept = () => {
+            this.releaseFocusTrap();
+            this.brCookiebarAccept.emit();
+            this.brCookiebarResponse.emit(this.buildOutputData());
+            this.show = false;
+        };
+        /**
+         * Rejeita todos os cookies opt-out: propaga `false` para grupos com `group-opt-out !== false`,
+         * recalcula `selectAllState`, libera o trap de foco, emite `brCookiebarReject` (void) e
+         * `brCookiebarResponse` (payload completo, construído uma única vez), depois oculta o componente.
+         */
+        this.handleReject = () => {
+            this.releaseFocusTrap();
+            this.propagateSelectAll(false);
+            this.recalculateSelectAll();
+            this.brCookiebarReject.emit();
+            this.brCookiebarResponse.emit(this.buildOutputData('reject'));
+            this.show = false;
+        };
+        /**
+         * Manipula o clique no botão secundário:
+         * - **opt-out**: abre o painel de configuração de cookies.
+         * - **opt-in**: emite `brCookiebarPolicyClick` para o consumidor navegar à política.
+         */
+        this.handleSecondaryButton = () => {
+            if (this.allOptOut) {
+                this.mode = 'open';
+            }
+            else {
+                this.brCookiebarPolicyClick.emit();
+            }
+        };
+        /** Fecha o painel aberto, retornando ao modo `default`. */
+        this.handleClose = () => {
+            this.releaseFocusTrap();
+            this.mode = 'default';
+        };
+        /** Atualiza `isMobile` conforme o breakpoint corrente. */
+        this.handleBreakpointChange = (breakpoint) => {
+            this.isMobile = breakpoint === BREAKPOINTS.X_SMALL;
+        };
+        /**
+         * Handler de trap de foco para o painel default.
+         * Ativado automaticamente pelo `scrim`: só prende o foco quando `scrim=true`,
+         * quando o modo é `default` e o componente está visível.
+         * Referência: WCAG 2.1.2.
+         */
+        this.defaultFocusTrapHandler = (event) => {
+            if (!this.show || this.mode !== 'default' || !this.scrim)
+                return;
+            const previewRoot = this.el.closest('.wbc-example-preview');
+            if (previewRoot && !event.composedPath().includes(previewRoot))
+                return;
+            if (!isEventTargetInside(event, this.el)) {
+                event.stopImmediatePropagation();
+                this.focusDefaultPanel();
+            }
+        };
+        /** Fecha o painel aberto ao pressionar Escape, apenas quando `show=true` e `mode="open"`. */
+        this.handleKeyDown = (event) => {
+            if (!this.show || this.mode !== 'open')
+                return;
+            if (this.usesNativeTopLayer && !isEventTargetInside(event, this.el))
+                return;
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                event.stopPropagation();
+                this.mode = 'default';
+            }
+        };
+    }
+    /**
+     * Observa mudanças em `show`.
+     * Ao exibir o componente, garante que o modo inicial seja sempre `default` e emite `brCookiebarShow`.
+     * Com `scrim=true`, aplica `inert` nos irmãos e registra o trap de foco.
+     * Com `scrim=false`, o usuário pode navegar livremente pela página (WCAG 2.1.2).
+     * Ao ocultar, emite `brCookiebarHide`.
+     */
+    handleShowChange(newValue) {
+        if (newValue) {
+            if (this.mode === 'open') {
+                this.mode = 'default';
+            }
+            this.pageTriggerElement = document.activeElement;
+            if (this.scrim) {
+                this.applyInertSiblings();
+                document.addEventListener('focusin', this.defaultFocusTrapHandler, true);
+            }
+            this.syncGlobalKeydownListener(true);
+            this.pendingFocusDefault = true;
+            this.brCookiebarShow.emit();
+        }
+        else {
+            this.syncGlobalKeydownListener(false);
+            this.releaseDefaultFocusTrap(true);
+            this.brCookiebarHide.emit();
+        }
+    }
+    /**
+     * Observa mudanças em `mode`.
+     * Ao entrar em modo `open`, emite `brCookiebarOpen`, aplica `inert` nos irmãos e move o foco
+     * para o botão fechar (trap focus modal).
+     * Ao sair do modo `open`, emite `brCookiebarClose` e — se `scrim=true` — reaplica `inert`
+     * e o listener de trap para o painel default. Sem scrim, nenhum trap é ativado.
+     */
+    handleModeChange(newValue) {
+        if (newValue === 'open') {
+            document.removeEventListener('focusin', this.defaultFocusTrapHandler, true);
+            this.brCookiebarOpen.emit();
+            this.trapFocus();
+            this.openLiveAnnouncement = '';
+            this.openPanelDescription = this.buildOpenPanelDescription();
+            if (this.openAnnouncementFrame !== null)
+                cancelAnimationFrame(this.openAnnouncementFrame);
+            this.openAnnouncementFrame = requestAnimationFrame(() => {
+                this.openAnnouncementFrame = null;
+                if (this.mode !== 'open')
+                    return;
+                this.openLiveAnnouncement = this.buildOpenAnnouncement();
+            });
+        }
+        else {
+            if (this.openAnnouncementFrame !== null) {
+                cancelAnimationFrame(this.openAnnouncementFrame);
+                this.openAnnouncementFrame = null;
+            }
+            this.openLiveAnnouncement = '';
+            this.brCookiebarClose.emit();
+            if (this.show && this.scrim) {
+                this.applyInertSiblings();
+                document.addEventListener('focusin', this.defaultFocusTrapHandler, true);
+            }
+            this.pendingFocusDefault = true;
+        }
+    }
+    handleScrimChange(newValue) {
+        this.releaseDefaultFocusTrap(false);
+        if (this.show && this.mode === 'default' && newValue) {
+            this.applyInertSiblings();
+            document.addEventListener('focusin', this.defaultFocusTrapHandler, true);
+        }
+    }
+    /**
+     * Observa mudanças externas na prop `selectAll`.
+     * Sincroniza o estado interno do checkbox e propaga o valor para todos os grupos opt-out.
+     */
+    handleSelectAllPropChange(newValue) {
+        this.selectAllState = newValue;
+        this.propagateSelectAll(newValue);
+    }
+    /**
+     * Remove o listener global de teclado quando o componente é removido do DOM,
+     * evitando memory leaks.
+     */
+    disconnectedCallback() {
+        if (this.openAnnouncementFrame !== null)
+            cancelAnimationFrame(this.openAnnouncementFrame);
+        this.openAnnouncementFrame = null;
+        this.syncGlobalKeydownListener(false);
+        this.slotChangeHandlers.forEach((handler, slot) => {
+            slot.removeEventListener('slotchange', handler);
+        });
+        this.slotChangeHandlers.clear();
+        document.removeEventListener('focusin', this.defaultFocusTrapHandler, true);
+        this.restoreInertSiblings();
+        this.triggerElement = null;
+        this.pageTriggerElement = null;
+        this.breakpointObserver?.destroy();
+        this.breakpointObserver = null;
+    }
+    /**
+     * Inicializa o estado interno do checkbox geral e detecta quais slots estão preenchidos
+     * antes da primeira renderização.
+     */
+    componentWillLoad() {
+        this.selectAllState = this.selectAll;
+        this.checkSlots();
+        if (!this.selectAll)
+            this.recalculateSelectAll();
+        if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {
+            this.breakpointObserver = new BreakpointObserver();
+            this.breakpointObserver.subscribe(this.handleBreakpointChange);
+        }
+    }
+    /**
+     * Registra um listener em cada slot para reatualizar a detecção quando o conteúdo muda dinamicamente.
+     * Também registra o listener global de teclado para fechar o painel com Escape.
+     */
+    componentDidLoad() {
+        const slotElements = this.el.shadowRoot?.querySelectorAll('slot');
+        slotElements?.forEach((slot) => {
+            const handler = () => this.checkSlots();
+            this.slotChangeHandlers.set(slot, handler);
+            slot.addEventListener('slotchange', handler);
+        });
+        this.syncGlobalKeydownListener(this.show);
+        this.syncNativeDialog();
+        if (this.show && this.mode === 'default') {
+            this.pageTriggerElement = document.activeElement;
+            if (this.scrim) {
+                this.applyInertSiblings();
+                document.addEventListener('focusin', this.defaultFocusTrapHandler, true);
+            }
+            this.focusDefaultPanel();
+        }
+    }
+    /**
+     * Executado após cada re-render. Consome as flags de foco pendente:
+     * - `pendingFocusDefault`: foca o painel default (DOM garantidamente pronto).
+     * - `pendingFocusOpen`: foca o painel open/dialog (DOM garantidamente pronto).
+     */
+    componentDidUpdate() {
+        this.syncNativeDialog();
+        if (this.pendingFocusDefault) {
+            this.pendingFocusDefault = false;
+            this.focusDefaultPanel();
+        }
+        if (this.pendingFocusOpen) {
+            this.pendingFocusOpen = false;
+            this.focusOpenPanel();
+        }
+    }
+    /**
+     * Escuta o evento `brCookiebarGroupChange` emitido por qualquer `br-cookiebar-group` filho.
+     * Apenas recalcula o estado visual do checkbox "Selecionar tudo" — não emite `brCookiebarResponse`.
+     * O evento de resposta completo é emitido somente ao clicar em Aceitar ou Rejeitar.
+     */
+    handleGroupChange() {
+        this.recalculateSelectAll();
+    }
+    /** Exibe o cookiebar no modo `default` (barra inferior). */
+    async openDefault() {
+        this.mode = 'default';
+        this.show = true;
+    }
+    /**
+     * Exibe o cookiebar diretamente no modo `open` (painel de tela cheia).
+     */
+    async openPanel() {
+        this.show = true;
+        this.mode = 'open';
+    }
+    /** Oculta o cookiebar. */
+    async close() {
+        this.show = false;
+    }
+    /** Retorna o JSON com o estado atual de seleção de todos os grupos e cookies. */
+    async getSelectedCookies() {
+        return this.buildOutputData();
+    }
+    get liveAnnouncement() {
+        if (this.mode === 'open')
+            return this.openLiveAnnouncement;
+        return this.show ? [this.defaultPanelLabel, this.infoText].filter(Boolean).join('. ') : '';
+    }
+    syncGlobalKeydownListener(shouldAttach) {
+        if (shouldAttach === this.globalKeydownAttached)
+            return;
+        if (shouldAttach)
+            document.addEventListener('keydown', this.handleKeyDown, true);
+        else
+            document.removeEventListener('keydown', this.handleKeyDown, true);
+        this.globalKeydownAttached = shouldAttach;
+    }
+    get usesNativeDialog() {
+        return this.show && (this.scrim || this.mode === 'open');
+    }
+    get usesNativeTopLayer() {
+        return this.usesNativeDialog && supportsNativeModalDialog();
+    }
+    syncNativeDialog() {
+        syncNativeModalDialog(this.nativeDialogRef, this.usesNativeDialog);
+    }
+    /** Verifica quais slots (`header`, `links`, `actions`) possuem conteúdo e atualiza os estados correspondentes. */
+    checkSlots() {
+        this.hasHeaderSlot = !!this.el.querySelector('[slot="header"]');
+        this.hasLinksSlot = !!this.el.querySelector('[slot="links"]');
+        this.hasActionsSlot = !!this.el.querySelector('[slot="actions"]');
+    }
+    /** Retorna todos os `br-cookiebar-group` filhos no Light DOM. */
+    getGroupElements() {
+        return Array.from(this.el.querySelectorAll('br-cookiebar-group'));
+    }
+    /**
+     * Deriva a descrição do painel `open` a partir do `entryText` do `br-cookiebar-header` filho.
+     * Usado como conteúdo do elemento sr-only referenciado por `aria-describedby` no diálogo.
+     * Retorna string vazia quando não há header ou o conteúdo é livre (sem `entryText`).
+     */
+    buildOpenPanelDescription() {
+        const header = this.el.querySelector('br-cookiebar-header');
+        if (!header)
+            return '';
+        return header.entryText ?? header.textContent?.trim() ?? '';
+    }
+    /**
+     * Monta o texto anunciado pela região `aria-live` ao entrar no modo `open`.
+     */
+    buildOpenAnnouncement() {
+        const header = this.el.querySelector('br-cookiebar-header');
+        const parts = [this.panelLabel];
+        if (header) {
+            const title = header.mainTitle ?? header.textContent?.trim() ?? '';
+            const text = header.entryText ?? '';
+            if (title)
+                parts.push(title);
+            if (text)
+                parts.push(text);
+        }
+        return parts.filter(Boolean).join('. ');
+    }
+    /**
+     * Recalcula o estado do checkbox "Selecionar tudo" com base nos grupos opt-out.
+     * Grupos `always-active` (`group-opt-out="false"`) são ignorados no cálculo.
+     * Define `selectAllState` como `true`, `false` ou `'indeterminate'`.
+     */
+    recalculateSelectAll() {
+        const groups = this.getGroupElements();
+        if (groups.length === 0)
+            return;
+        const optOutGroups = groups.filter((g) => g.groupOptOut !== false);
+        if (optOutGroups.length === 0) {
+            this.selectAllState = true;
+            return;
+        }
+        const states = optOutGroups.map((group) => this.getGroupSelectionState(group));
+        this.selectAllState = aggregateSelection(states);
+    }
+    /** Calcula a seleção de um grupo a partir de propriedades refletidas ou atributos iniciais. */
+    getGroupSelectionState(group) {
+        const cookies = Array.from(group.children).filter((element) => element.tagName.toLowerCase() === 'br-cookiebar-cookie');
+        const selectableCookies = cookies.filter((cookie) => cookie.getAttribute('cookie-opt-out') !== 'false');
+        if (selectableCookies.length === 0) {
+            const selectedAttribute = group.getAttribute('group-selected');
+            return (selectedAttribute !== null && selectedAttribute !== 'false') || group.groupSelected === true;
+        }
+        return aggregateSelection(selectableCookies.map((cookie) => cookie.hasAttribute('cookie-selected') && cookie.getAttribute('cookie-selected') !== 'false'));
+    }
+    /**
+     * Propaga um valor booleano para todos os grupos opt-out filhos,
+     * atribuindo diretamente à propriedade JS para acionar o `@Watch('groupSelected')` de cada grupo.
+     */
+    propagateSelectAll(value) {
+        const groups = this.getGroupElements();
+        groups.forEach((g) => {
+            if (g.groupOptOut !== false) {
+                g.groupSelected = value;
+            }
+        });
+    }
+    /**
+     * Monta o objeto `CookiebarOutputData` percorrendo todos os grupos e seus cookies
+     * via atributos refletidos, retornando o estado atual de consentimento.
+     */
+    buildOutputData(policy = 'current') {
+        const groups = this.getGroupElements();
+        const cookieGroups = groups.map((g) => {
+            const groupId = g.groupId ?? g.getAttribute('group-id') ?? '';
+            const isAlwaysActive = g.groupOptOut === false;
+            const indeterminate = g.hasAttribute('data-indeterminate');
+            const groupSelected = isAlwaysActive
+                ? true
+                : policy === 'reject'
+                    ? false
+                    : indeterminate
+                        ? 'indeterminate'
+                        : g.groupSelected;
+            const cookieElements = Array.from(g.querySelectorAll('br-cookiebar-cookie'));
+            const cookieList = cookieElements.map((c) => ({
+                cookieId: c.cookieId ?? c.getAttribute('cookie-id') ?? '',
+                cookieSelected: isAlwaysActive || c.cookieOptOut === false ? true : policy === 'reject' ? false : c.cookieSelected,
+            }));
+            return { groupId, groupSelected, cookieList };
+        });
+        return { selectAll: policy === 'reject' ? false : this.selectAllState, cookieGroups };
+    }
+    /**
+     * Move o foco para o primeiro botão focável dentro do painel default.
+     * Recai no container do painel (`tabindex="-1"`) se nenhum botão for encontrado.
+     */
+    focusDefaultPanel() {
+        const panel = this.defaultPanelRef;
+        if (!panel)
+            return;
+        const firstButton = panel.querySelector('br-button');
+        const nativeButton = firstButton?.shadowRoot?.querySelector('button');
+        if (nativeButton) {
+            nativeButton.focus();
+        }
+        else {
+            panel.focus();
+        }
+    }
+    /**
+     * Move o foco para o botão fechar do painel expandido, que é o primeiro elemento
+     * interativo do diálogo (WCAG 2.4.3 / padrão ARIA dialog).
+     * O botão fechar fica no cabeçalho, antes dos grupos e do rodapé, garantindo que
+     * o leitor de tela anuncie "Fechar, botão" ao entrar no diálogo e permita ao usuário
+     * percorrer o conteúdo na ordem natural com Tab.
+     * Recai no container do painel (`tabindex="-1"`) se o botão não for encontrado.
+     */
+    focusOpenPanel() {
+        const shadow = this.el.shadowRoot;
+        const closeButton = shadow?.querySelector('br-button.cookiebar-close');
+        const nativeButton = closeButton?.shadowRoot?.querySelector('button');
+        if (nativeButton) {
+            nativeButton.focus();
+        }
+        else {
+            const panel = shadow?.querySelector('[part="open-panel"]');
+            panel?.focus();
+        }
+    }
+    /**
+     * Remove o listener de trap do painel default, restaura `inert` dos irmãos e,
+     * opcionalmente, restaura o foco no elemento que estava ativo antes do cookiebar aparecer.
+     */
+    releaseDefaultFocusTrap(restoreFocus = true) {
+        document.removeEventListener('focusin', this.defaultFocusTrapHandler, true);
+        this.restoreInertSiblings();
+        if (restoreFocus) {
+            this.pageTriggerElement?.focus();
+        }
+        this.pageTriggerElement = null;
+    }
+    /**
+     * Remove o `inert` dos irmãos e restaura o foco no elemento disparador.
+     * Chamado em `handleClose`, `handleAccept` e `handleReject`.
+     */
+    releaseFocusTrap() {
+        this.restoreInertSiblings();
+        this.triggerElement?.focus();
+        this.triggerElement = null;
+    }
+    /**
+     * Aplica `inert` nos irmãos do cookiebar e nos irmãos de cada ancestral até o `<body>`.
+     * Preserva os elementos já rastreados em chamadas sucessivas para que uma transição
+     * entre os modos `default` e `open` não perca a referência necessária à restauração.
+     *
+     * Percorre a cadeia de ancestrais de baixo para cima e, em cada nível, inercia todos
+     * os irmãos do nó que contém o cookiebar. Como `inert` é herdado por todos os
+     * descendentes, isso garante que nenhum elemento fora do cookiebar receba foco — via
+     * Tab ou cursor virtual de leitor de tela — independentemente da profundidade de
+     * aninhamento do cookiebar no DOM.
+     *
+     * Referência: WCAG 2.1.2 / ARIA dialog pattern.
+     */
+    applyInertSiblings() {
+        const previewRoot = this.el.closest('.wbc-example-preview');
+        let el = this.el;
+        while (el.parentElement) {
+            Array.from(el.parentElement.children).forEach((sibling) => {
+                if (sibling === el)
+                    return;
+                if (!sibling.inert) {
+                    sibling.inert = true;
+                    this.inertedElements.push(sibling);
+                }
+            });
+            if (previewRoot && el.parentElement === previewRoot)
+                break;
+            if (el.parentElement === document.body)
+                break;
+            el = el.parentElement;
+        }
+    }
+    /**
+     * Remove `inert` dos elementos que foram marcados por `applyInertSiblings`.
+     */
+    restoreInertSiblings() {
+        this.inertedElements.forEach((el) => {
+            el.inert = false;
+        });
+        this.inertedElements = [];
+    }
+    /**
+     * Ativa o trap de foco: salva o elemento disparador, inercia todos os
+     * filhos diretos de `<body>` exceto o ancestral do cookiebar (bloqueando tab e
+     * cursor virtual do leitor de tela em toda a página) e sinaliza foco pendente.
+     * O foco efetivo no botão fechar do painel é delegado ao `componentDidUpdate`
+     * via `pendingFocusOpen`, garantindo que o AT anuncie "Fechar, botão" ao entrar
+     * no diálogo e permita percorrer o conteúdo na ordem natural (WCAG 2.4.3).
+     * Referência: WCAG 2.1.2 / 2.4.3.
+     */
+    trapFocus() {
+        this.triggerElement = document.activeElement;
+        this.applyInertSiblings();
+        this.pendingFocusOpen = true;
+    }
+    /** Gera o mapa de classes CSS do container raiz com base no `mode` atual. */
+    getCssClassMap() {
+        return {
+            'br-cookiebar': true,
+            [`br-cookiebar--${this.mode}`]: true,
+            'br-cookiebar--blocking': this.usesNativeDialog,
+        };
+    }
+    /**
+     * Renderiza o checkbox "Selecionar tudo" com seu estado atual e a mensagem de alerta
+     * exibida quando nenhum ou apenas alguns grupos estão selecionados.
+     */
+    renderSelectAllCheckbox() {
+        const isIndeterminate = this.selectAllState === 'indeterminate';
+        const isChecked = this.selectAllState === true;
+        const label = isChecked ? this.unselectAllLabel : this.selectAllLabel;
+        return (h("div", { class: "cookiebar-select-all" }, h("br-checkbox", { name: "cookiebar-select-all", checked: isChecked, indeterminate: isIndeterminate, label: label, onCheckedChange: this.handleSelectAllChange })));
+    }
+    /**
+     * Renderiza o painel no modo `default` (barra inferior) com o texto informativo,
+     * o scrim opcional e os botões de ação.
+     */
+    renderDefaultPanel() {
+        return (h("div", { class: "cookiebar-default-panel", part: "default-panel", role: "region", "aria-label": this.defaultPanelLabel, tabindex: "-1", ref: (el) => (this.defaultPanelRef = el) }, h("div", { class: "cookiebar-default-content" }, h("p", { class: "cookiebar-info-text" }, this.infoText)), h("div", { class: "cookiebar-actions", part: "footer" }, this.hasActionsSlot ? h("slot", { name: "actions" }) : this.renderDefaultActions())));
+    }
+    /**
+     * Renderiza os botões padrão do modo `default` quando o slot `actions` não está preenchido.
+     * No modo opt-out, exibe "Definir Cookies" + opcionalmente "Rejeitar não obrigatórios" + "Aceitar".
+     * No modo opt-in, exibe "Ver Política de Cookies" + opcionalmente "Rejeitar não obrigatórios" + "Aceitar".
+     */
+    renderDefaultActions() {
+        const secondaryLabel = this.allOptOut ? this.optOutButton : this.optInButton;
+        return (h("div", { class: "cookiebar-default-actions" }, h("br-button", { emphasis: "secondary", density: "small", shape: this.actionShape, "aria-haspopup": this.allOptOut ? 'dialog' : undefined, onClick: this.handleSecondaryButton }, secondaryLabel), this.renderConsentActions()));
+    }
+    get actionShape() {
+        return this.isMobile ? 'block' : undefined;
+    }
+    /** Renderiza as ações de consentimento compartilhadas pelos dois painéis. */
+    renderConsentActions() {
+        return [
+            this.showRejectButton && (h("br-button", { emphasis: "secondary", density: "small", shape: this.actionShape, onClick: this.handleReject }, this.rejectButton)),
+            h("br-button", { emphasis: "primary", density: "small", shape: this.actionShape, onClick: this.handleAccept }, this.acceptButton),
+        ];
+    }
+    renderCookieGroupsHeader() {
+        return (h("div", { class: "cookiebar-groups-header" }, h("div", { role: "heading", "aria-level": 2, class: "cookiebar-groups-label" }, this.cookieGroupsLabel), this.renderSelectAllCheckbox(), this.renderSelectAllAlert()));
+    }
+    renderSelectAllAlert() {
+        if (!this.allAlertMessage)
+            return null;
+        if (this.selectAllState !== false && this.selectAllState !== 'indeterminate')
+            return null;
+        return (h("div", { class: "cookiebar-alert-wrapper" }, h("br-message", { state: "warning", "show-icon": true, "is-feedback": true, message: this.allAlertMessage })));
+    }
+    /**
+     * Renderiza o painel no modo `open` (tela cheia) com as áreas B (cabeçalho),
+     * C (grupos de cookies), D (links complementares) e E (botão de aceite).
+     */
+    renderOpenPanel() {
+        return (h("div", { class: "cookiebar-open-panel", part: "open-panel", role: "dialog", "aria-modal": "true", "aria-label": this.panelLabel, "aria-describedby": this.openPanelDescription ? `${this.customId}-desc` : undefined, tabindex: "-1" }, this.openPanelDescription && (h("span", { id: `${this.customId}-desc`, class: "sr-only" }, this.openPanelDescription)), h("div", { class: "cookiebar-body", part: "body" }, h("div", { class: "cookiebar-header", part: "header" }, this.hasHeaderSlot && h("slot", { name: "header" }), h("br-button", { class: "cookiebar-close", emphasis: "tertiary", shape: "circle", "aria-label": this.closeLabel, onClick: this.handleClose }, h("br-icon", { iconName: "fa6-solid:xmark", width: "16", height: "16" }))), h("div", { class: "cookiebar-groups" }, this.renderCookieGroupsHeader(), h("slot", null)), this.hasLinksSlot && (h("nav", { class: "cookiebar-links", "aria-label": this.linksLabel }, h("slot", { name: "links" })))), h("div", { class: "cookiebar-actions", part: "footer" }, this.hasActionsSlot ? h("slot", { name: "actions" }) : this.renderConsentActions())));
+    }
+    render() {
+        const containerContent = [
+            this.mode === 'default' && this.scrim && h("div", { key: 'e032d3e30e9e7a604207e7d5608eed48f602fba0', class: "cookiebar-scrim", part: "scrim", "aria-hidden": "true" }),
+            this.mode === 'default' ? this.renderDefaultPanel() : this.renderOpenPanel(),
+        ];
+        return (h(Host, { key: '795000ece30e44b33cd24c2b02dc70f21656f6f6' }, h("div", { key: 'bd11d082c5f2b3dc35bff48a636edda720f8b060', "aria-live": "polite", "aria-atomic": "true", class: "sr-only" }, this.liveAnnouncement), this.show &&
+            (this.usesNativeDialog ? (h("dialog", { ref: (el) => (this.nativeDialogRef = el), class: this.getCssClassMap(), part: "container", role: this.usesNativeTopLayer ? undefined : 'dialog', "aria-modal": "true", "aria-label": this.mode === 'open' ? this.panelLabel : this.defaultPanelLabel, "aria-describedby": this.mode === 'open' && this.openPanelDescription ? `${this.customId}-desc` : undefined, onCancel: this.handleNativeCancel }, containerContent)) : (h("div", { ref: () => (this.nativeDialogRef = null), class: this.getCssClassMap(), part: "container" }, containerContent)))));
+    }
+    static get is() { return "br-cookiebar"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["cookiebar.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["cookiebar.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "customId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Identificador \u00FAnico; gerado automaticamente quando omitido."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "custom-id",
+                "defaultValue": "generateUniqueId()"
+            },
+            "show": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Controla a visibilidade do componente.\nO consumidor \u00E9 respons\u00E1vel por definir este valor com base na persist\u00EAncia do consentimento\n(ex: verificar se j\u00E1 existe um cookie de consentimento salvo)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "show",
+                "defaultValue": "false"
+            },
+            "mode": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "CookiebarMode",
+                    "resolved": "\"default\" | \"open\"",
+                    "references": {
+                        "CookiebarMode": {
+                            "location": "import",
+                            "path": "./cookiebar.types",
+                            "id": "src/components/cookiebar/cookiebar.types.ts::CookiebarMode",
+                            "referenceLocation": "CookiebarMode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Estado visual atual do painel.\n- `default`: barra inferior com texto e bot\u00F5es.\n- `open`: painel de tela cheia com grupos de cookies configur\u00E1veis."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "mode",
+                "defaultValue": "'default'"
+            },
+            "allOptOut": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define se o cookiebar opera no padr\u00E3o opt-out (`true`, recomendado) ou opt-in (`false`).\n- **opt-out** (`true`): bot\u00E3o secund\u00E1rio \"Definir Cookies\"; usu\u00E1rio pode configurar cookies.\n- **opt-in** (`false`): bot\u00E3o secund\u00E1rio \"Ver Pol\u00EDtica de Cookies\"; painel \u00E9 somente leitura."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "all-opt-out",
+                "defaultValue": "true"
+            },
+            "infoText": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto informativo exibido na barra inferior (modo default), descrevendo a pol\u00EDtica de cookies."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "info-text"
+            },
+            "acceptButton": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto do bot\u00E3o prim\u00E1rio de aceite. Padr\u00E3o: `Aceitar`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "accept-button",
+                "defaultValue": "'Aceitar'"
+            },
+            "rejectButton": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto do bot\u00E3o de rejei\u00E7\u00E3o dos cookies n\u00E3o obrigat\u00F3rios.\nExibido apenas quando `show-reject-button=\"true\"`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "reject-button",
+                "defaultValue": "'Rejeitar n\u00E3o obrigat\u00F3rios'"
+            },
+            "showRejectButton": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Quando `true`, exibe o bot\u00E3o \"Rejeitar n\u00E3o obrigat\u00F3rios\" nos pain\u00E9is default e open.\nCookies de grupos com `group-opt-out=\"false\"` (sempre ativos) n\u00E3o s\u00E3o afetados."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "show-reject-button",
+                "defaultValue": "false"
+            },
+            "optOutButton": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto do bot\u00E3o secund\u00E1rio quando `all-opt-out=\"true\"`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "opt-out-button",
+                "defaultValue": "'Definir Cookies'"
+            },
+            "optInButton": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto do bot\u00E3o secund\u00E1rio quando `all-opt-out=\"false\"`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "opt-in-button",
+                "defaultValue": "'Ver Pol\u00EDtica de Cookies'"
+            },
+            "closeLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "`aria-label` do bot\u00E3o fechar exibido no canto do painel expandido (`mode=\"open\"`).\nPermite traduzir o r\u00F3tulo para outros idiomas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "close-label",
+                "defaultValue": "'Fechar'"
+            },
+            "panelLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "`aria-label` do painel expandido (`mode=\"open\"`), que possui `role=\"dialog\"`.\nLeitores de tela anunciam este texto ao entrar no di\u00E1logo modal de configura\u00E7\u00E3o de cookies.\nDeve descrever o prop\u00F3sito do di\u00E1logo de forma sucinta (ex: \"Configura\u00E7\u00F5es de cookies\")."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "panel-label",
+                "defaultValue": "'Configura\u00E7\u00F5es de cookies'"
+            },
+            "defaultPanelLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "`aria-label` da barra de aviso de cookies (`mode=\"default\"`).\nDeve descrever o prop\u00F3sito da regi\u00E3o de forma sucinta (ex: \"Aviso de cookies\")."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "default-panel-label",
+                "defaultValue": "'Aviso de cookies'"
+            },
+            "cookieGroupsLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "R\u00F3tulo do t\u00EDtulo da se\u00E7\u00E3o de grupos de cookies."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "cookie-groups-label",
+                "defaultValue": "'Classes de cookies'"
+            },
+            "linksLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "`aria-label` do elemento `<nav>` que envolve os links complementares no painel expandido.\nPermite traduzir o r\u00F3tulo para outros idiomas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "links-label",
+                "defaultValue": "'Links complementares'"
+            },
+            "selectAll": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Estado inicial do checkbox \"Selecionar tudo\".\nQuando `true`, todos os grupos opt-out iniciam selecionados."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "select-all",
+                "defaultValue": "false"
+            },
+            "selectAllLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto do checkbox geral quando est\u00E1 totalmente selecionado (a\u00E7\u00E3o: desselecionar)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "select-all-label",
+                "defaultValue": "'Selecionar tudo'"
+            },
+            "unselectAllLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Texto do checkbox geral quando est\u00E1 desmarcado ou indeterminado (a\u00E7\u00E3o: selecionar)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "unselect-all-label",
+                "defaultValue": "'Desselecionar tudo'"
+            },
+            "allAlertMessage": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Mensagem exibida abaixo do checkbox geral quando est\u00E1 desmarcado ou com sele\u00E7\u00E3o parcial."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "all-alert-message"
+            },
+            "scrim": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Quando `true`, exibe uma camada semitransparente (scrim) sobre o conte\u00FAdo da p\u00E1gina\nabaixo do painel default, sinalizando que o cookiebar requer aten\u00E7\u00E3o.\n\n**Efeito no foco:** com `scrim=true`, o atributo `inert` \u00E9 aplicado nos irm\u00E3os do\ncookiebar no DOM, prendendo o foco e o cursor virtual do leitor de tela dentro do\npainel default enquanto ele estiver vis\u00EDvel. Com `scrim=false` (padr\u00E3o), nenhum trap\n\u00E9 ativado \u2014 o usu\u00E1rio pode navegar livremente pela p\u00E1gina, em conformidade com\nWCAG 2.1.2 (No Keyboard Trap). Use `scrim=true` apenas quando o cen\u00E1rio de neg\u00F3cio\nexigir que a decis\u00E3o sobre cookies seja tomada antes de qualquer outra intera\u00E7\u00E3o.\n\nNo modo `open` (di\u00E1logo modal), o `inert` \u00E9 aplicado independentemente do valor de `scrim`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "scrim",
+                "defaultValue": "false"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "openPanelDescription": {},
+            "hasActionsSlot": {},
+            "hasHeaderSlot": {},
+            "hasLinksSlot": {},
+            "isMobile": {},
+            "openLiveAnnouncement": {},
+            "selectAllState": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "brCookiebarShow",
+                "name": "brCookiebarShow",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o componente se torna vis\u00EDvel (`show` \u2192 true)."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brCookiebarHide",
+                "name": "brCookiebarHide",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o componente \u00E9 ocultado (`show` \u2192 false)."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brCookiebarOpen",
+                "name": "brCookiebarOpen",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o painel expande para modo open."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brCookiebarClose",
+                "name": "brCookiebarClose",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o painel recolhe para modo default."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brCookiebarAccept",
+                "name": "brCookiebarAccept",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Sinal emitido quando o usu\u00E1rio clica em Aceitar.\nN\u00E3o carrega payload \u2014 ou\u00E7a `brCookiebarResponse` para obter o estado completo de consentimento."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brCookiebarReject",
+                "name": "brCookiebarReject",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Sinal emitido quando o usu\u00E1rio clica em \"Rejeitar n\u00E3o obrigat\u00F3rios\".\nN\u00E3o carrega payload \u2014 ou\u00E7a `brCookiebarResponse` para obter o estado completo de consentimento."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brCookiebarResponse",
+                "name": "brCookiebarResponse",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido ap\u00F3s `brCookiebarAccept` ou `brCookiebarReject`, com o estado final de consentimento.\n\u00C9 o \u00FAnico evento que carrega `CookiebarOutputData` \u2014 use-o para persistir o consentimento\n(localStorage, cookie HTTP, API etc.).\nN\u00E3o \u00E9 disparado durante intera\u00E7\u00F5es com checkboxes e switches internos."
+                },
+                "complexType": {
+                    "original": "CookiebarOutputData",
+                    "resolved": "CookiebarOutputData",
+                    "references": {
+                        "CookiebarOutputData": {
+                            "location": "import",
+                            "path": "./cookiebar.types",
+                            "id": "src/components/cookiebar/cookiebar.types.ts::CookiebarOutputData",
+                            "referenceLocation": "CookiebarOutputData"
+                        }
+                    }
+                }
+            }, {
+                "method": "brCookiebarPolicyClick",
+                "name": "brCookiebarPolicyClick",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o usu\u00E1rio clica no bot\u00E3o secund\u00E1rio no modo opt-in (`allOptOut=false`).\nO consumidor \u00E9 respons\u00E1vel por navegar para a p\u00E1gina de Pol\u00EDtica de Cookies."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "openDefault": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Exibe o cookiebar no modo `default` (barra inferior).",
+                    "tags": []
+                }
+            },
+            "openPanel": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Exibe o cookiebar diretamente no modo `open` (painel de tela cheia).",
+                    "tags": []
+                }
+            },
+            "close": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Oculta o cookiebar.",
+                    "tags": []
+                }
+            },
+            "getSelectedCookies": {
+                "complexType": {
+                    "signature": "() => Promise<CookiebarOutputData>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "CookiebarOutputData": {
+                            "location": "import",
+                            "path": "./cookiebar.types",
+                            "id": "src/components/cookiebar/cookiebar.types.ts::CookiebarOutputData",
+                            "referenceLocation": "CookiebarOutputData"
+                        }
+                    },
+                    "return": "Promise<CookiebarOutputData>"
+                },
+                "docs": {
+                    "text": "Retorna o JSON com o estado atual de sele\u00E7\u00E3o de todos os grupos e cookies.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "show",
+                "methodName": "handleShowChange"
+            }, {
+                "propName": "mode",
+                "methodName": "handleModeChange"
+            }, {
+                "propName": "scrim",
+                "methodName": "handleScrimChange"
+            }, {
+                "propName": "selectAll",
+                "methodName": "handleSelectAllPropChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "brCookiebarGroupChange",
+                "method": "handleGroupChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}