@govbr-ds/webcomponents 2.0.0-next.56 → 2.0.0-next.58

package/dist/collection/components/menu/menu.js

@@ -0,0 +1,1064 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { h, Host } from "@stencil/core";
+/**
+ * Componente raiz do Menu responsivo do Design System. Ele organiza navegação hierárquica, rodapé contextual e
+ * comportamentos como push/contextual, integrando `br-menu-list`, `br-menu-item` e subcomponentes auxiliares.
+ *
+ * @example
+ * ```html
+ * <br-menu push>
+ *   <div slot="header">Minha aplicação</div>
+ *   <br-menu-list label="Administração">
+ *     <br-menu-item href="/dashboard" active>Dashboard</br-menu-item>
+ *     <br-menu-item href="/usuarios">Usuários</br-menu-item>
+ *   </br-menu-list>
+ * </br-menu>
+ * ```
+ *
+ * @slot default - Conteúdo principal do menu (menu-list e menu-item)
+ * @slot header - Cabeçalho do menu (exibido apenas em modo não-contextual)
+ * @slot logo - Logotipos de parceiros no rodapé
+ * @slot link - Links externos no rodapé (use br-menu-link)
+ * @slot social - Ícones de redes sociais no rodapé
+ * @slot info - Informações adicionais no rodapé
+ *
+ * @part footer - O contêiner principal do rodapé do menu, que agrupa as seções de logos, links, redes sociais e informações.
+ * @part logo - A área específica para exibir os logotipos de parceiros ou relacionados, dentro do rodapé.
+ * @part link - A seção destinada a links úteis ou de navegação secundária no rodapé do menu.
+ * @part social - O contêiner para os ícones de redes sociais.
+ * @part info - Uma área para informações adicionais, como textos de licença ou direitos autorais.
+ */
+export class Menu {
+    constructor() {
+        /**
+         * Classes CSS para definir breakpoints responsivos do menu.
+         * Utilize esta propriedade para controlar a largura do menu em diferentes tamanhos de tela.
+         * @default 'col-sm-4 col-lg-3'
+         */
+        // Por padrão não aplica colunas; quando contextual e sem valor definido, usa 'col-sm-4 col-lg-3'
+        this.breakpoints = '';
+        /**
+         * Define se o menu deve usar comportamento push (sempre visível em telas maiores).
+         * Quando ativado, o menu permanece fixo na lateral e empurra o conteúdo principal.
+         * @default false
+         */
+        this.push = false;
+        /**
+         * Define se o menu deve usar comportamento contextual (aparece na parte inferior).
+         * Quando ativado, o menu é posicionado na parte inferior da tela em dispositivos móveis.
+         * @default false
+         */
+        this.contextual = false;
+        /**
+         * Define a densidade dos itens do menu, alterando o espaçamento interno.
+         * - `small` (densidade alta): itens mais compactos
+         * - `medium` (padrão): equilíbrio entre economia de espaço e separação
+         * - `large` (densidade baixa): maior espaçamento (recomendado em touch)
+         * @default 'medium'
+         */
+        this.density = 'medium';
+        /**
+         * Título da seção de redes sociais exibida no rodapé do menu.
+         * Utilize esta propriedade para personalizar o texto que aparece acima dos ícones sociais.
+         * @default 'Redes Sociais'
+         */
+        this.socialTitle = 'Redes Sociais';
+        /**
+         * Rótulo do botão trigger do menu contextual.
+         * Exibido apenas em modo contextual e em telas menores (mobile).
+         * @default 'Menu Contextual'
+         */
+        this.contextualLabel = 'Menu Contextual';
+        // Define se o menu está aberto/visível ou fechado
+        this.active = false;
+        // Indica se o menu está exibindo um submenu (drill-down ativo)
+        this.inSubmenu = false;
+        // Representa o nível atual de navegação no drill-down (0 para o nível raiz)
+        this.currentLevel = 0;
+        // Controla quais menus drop-down estão expandidos no modo acordeão
+        this.expandedDropMenus = {};
+        // Pilha de navegação para controle do drill-down e navegação de volta
+        this.navigationStack = [];
+        // Armazena o elemento que tinha foco antes do menu abrir (para restaurar o foco ao fechar)
+        this.previouslyFocusedElement = null;
+        // IDs dos requestAnimationFrame para cancelamento no cleanup
+        this.rafIds = [];
+        this.handleToggleMenu = () => {
+            this.toggleMenu();
+        };
+        this.handleGoBack = () => {
+            this.goBack();
+        };
+        this.handleCloseMenu = () => {
+            this.closeMenu();
+        };
+    }
+    componentDidLoad() {
+        // Garante que apenas um item tenha active no carregamento inicial
+        this.ensureSingleActiveItem();
+    }
+    /**
+     * Método do ciclo de vida do componente.
+     * Este método é chamado quando o componente é desconectado do DOM.
+     * Realiza limpeza de recursos para evitar vazamento de memória.
+     */
+    disconnectedCallback() {
+        // Cancela todos os requestAnimationFrame pendentes
+        this.rafIds.forEach((id) => cancelAnimationFrame(id));
+        this.rafIds = [];
+    }
+    ensureSingleActiveItem() {
+        const allMenuItems = this.el.querySelectorAll('br-menu-item');
+        let firstActiveItem = null;
+        // Encontra o primeiro item com active e remove dos demais
+        for (let i = 0; i < allMenuItems.length; i++) {
+            const item = allMenuItems[i];
+            // Verifica se o item tem active
+            if (item.active || item.hasAttribute('active')) {
+                // Se é um header de menu-list (folder), remove o active
+                const displayMode = item.getAttribute('display-mode');
+                if (displayMode && displayMode !== 'none') {
+                    item.active = false;
+                    item.removeAttribute('active');
+                    continue;
+                }
+                // Se já encontramos um item ativo antes, remove deste
+                if (firstActiveItem) {
+                    item.active = false;
+                    item.removeAttribute('active');
+                }
+                else {
+                    // É o primeiro item ativo válido
+                    firstActiveItem = item;
+                    item.active = true;
+                }
+            }
+        }
+    }
+    handleMenuItemClick(ev) {
+        var _a;
+        // Busca o menu-item mais próximo do alvo do clique
+        const path = ev.composedPath();
+        let menuItemHost = null;
+        // Percorre o caminho do evento para encontrar o br-menu-item
+        for (const element of path) {
+            if (element instanceof HTMLElement && element.tagName === 'BR-MENU-ITEM') {
+                menuItemHost = element;
+                break;
+            }
+            // Para quando chegar no host do menu
+            if (element === this.el)
+                break;
+        }
+        if (!menuItemHost || !this.el.contains(menuItemHost))
+            return;
+        // Ignora se for um header de menu-list (folder/dropdown que tem filhos)
+        // Menus que expandem/têm submenus não devem receber classe active
+        const parentMenuList = menuItemHost.parentElement;
+        if ((parentMenuList === null || parentMenuList === void 0 ? void 0 : parentMenuList.tagName) === 'BR-MENU-LIST') {
+            // Se é filho direto de br-menu-list, verifica se é o header (primeiro br-menu-item)
+            const header = (_a = parentMenuList.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('br-menu-item');
+            if (header === menuItemHost) {
+                // É um header de folder, não deve receber active
+                return;
+            }
+        }
+        // Também verifica via atributo display-mode
+        const displayMode = menuItemHost.getAttribute('display-mode');
+        if (displayMode && displayMode !== 'none') {
+            return;
+        }
+        // Remove active de todos os menu-items
+        const allMenuItems = this.el.querySelectorAll('br-menu-item');
+        for (let i = 0; i < allMenuItems.length; i++) {
+            const item = allMenuItems[i];
+            item.active = false;
+        }
+        // Marca o item clicado como ativo
+        ;
+        menuItemHost.active = true;
+    }
+    handleKeyDown(ev) {
+        var _a;
+        // Permite ativar o botão contextual com Enter ou Espaço quando o menu está fechado
+        if (!this.active && this.contextual && (ev.key === 'Enter' || ev.key === ' ')) {
+            const target = ev.target;
+            const isContextualButton = ((_a = target === null || target === void 0 ? void 0 : target.closest) === null || _a === void 0 ? void 0 : _a.call(target, '#contextual-trigger')) || (target === null || target === void 0 ? void 0 : target.id) === 'contextual-trigger';
+            if (isContextualButton) {
+                ev.preventDefault();
+                this.toggleMenu();
+                return;
+            }
+        }
+        if (!this.active)
+            return;
+        const targetEl = ev.target;
+        const isFormField = targetEl &&
+            (targetEl.tagName === 'INPUT' ||
+                targetEl.tagName === 'TEXTAREA' ||
+                targetEl.tagName === 'SELECT' ||
+                targetEl.isContentEditable);
+        // Focus trap: gerencia Tab/Shift+Tab para manter o foco dentro do menu
+        if (ev.key === 'Tab') {
+            const focusableElements = this.getFocusableElements();
+            if (focusableElements.length === 0)
+                return;
+            const firstElement = focusableElements[0];
+            const lastElement = focusableElements[focusableElements.length - 1];
+            const deepActive = this.getDeepActiveElement();
+            // Se Tab sem Shift e está no último elemento, volta para o primeiro
+            if (!ev.shiftKey && deepActive === lastElement) {
+                ev.preventDefault();
+                firstElement.focus();
+                return;
+            }
+            // Se Shift+Tab e está no primeiro elemento, vai para o último
+            if (ev.shiftKey && deepActive === firstElement) {
+                ev.preventDefault();
+                lastElement.focus();
+                return;
+            }
+        }
+        // Voltar/fechar
+        if (this.inSubmenu && (ev.key === 'ArrowLeft' || ev.key === 'Backspace' || ev.key === 'Escape')) {
+            ev.preventDefault();
+            this.goBack();
+            return;
+        }
+        if (!this.inSubmenu && ev.key === 'Escape') {
+            ev.preventDefault();
+            this.closeMenu();
+            return;
+        }
+        // Navegação global por setas (fallback para todos os tipos de menu)
+        if (!isFormField && (ev.key === 'ArrowDown' || ev.key === 'ArrowUp')) {
+            const deepActive = this.getDeepActiveElement();
+            if (deepActive == null || !this.isNodeWithinHost(deepActive))
+                return;
+            ev.preventDefault();
+            ev.stopPropagation();
+            // No modo contextual ou quando não há drill-down ativo, navega por todos os itens visíveis
+            const useGlobalNavigation = this.contextual || !this.inSubmenu;
+            const targets = useGlobalNavigation ? this.getAllVisibleTargets() : this.getScopedTargets(deepActive);
+            if (targets.length === 0)
+                return;
+            let index = targets.findIndex((t) => t === deepActive || (deepActive instanceof Node && t.contains(deepActive)));
+            if (index === -1)
+                index = 0;
+            const nextIndex = ev.key === 'ArrowDown' ? (index + 1) % targets.length : (index - 1 + targets.length) % targets.length;
+            targets[nextIndex].focus();
+        }
+    }
+    handleNavigateToSubmenu(ev) {
+        const { element, label } = ev.detail;
+        const itemId = element.getAttribute('data-menu-id') || `menu-${Date.now()}`;
+        // Obter o nível real do menu do elemento
+        const menuLevel = parseInt(element.getAttribute('menu-level') || '0', 10);
+        // Aplicar a regra principal: comportamento por nível
+        if (menuLevel === 0) {
+            // Camada 1: Comportamento de acordeão
+            this.toggleDropMenu(itemId);
+        }
+        else {
+            // Camada 2+: Comportamento drill-down
+            this.navigateToLevel({ element, label, id: itemId });
+        }
+    }
+    handleFolderToggled(ev) {
+        const element = ev.target;
+        const itemId = element.getAttribute('data-menu-id') || `menu-${Date.now()}`;
+        if (ev.detail) {
+            // Se o folder foi expandido, fecha todos os outros no nível 0
+            this.collapseOtherFolders(itemId);
+        }
+    }
+    handleMenuHeaderClose() {
+        this.closeMenu();
+    }
+    /**
+     * Alterna o estado expandido de um menu drop-down no modo acordeão.
+     *
+     * Este método recebe o identificador único (`itemId`) de um menu do tipo drop-down (nível 0)
+     * e inverte o seu estado de expansão dentro do objeto `expandedDropMenus`.
+     *
+     * Se o menu estiver atualmente expandido, ele será recolhido; se estiver recolhido, será expandido.
+     * O spread operator (`...this.expandedDropMenus`) garante que os estados dos outros menus sejam preservados.
+     *
+     * @param itemId - Identificador único do menu drop-down a ser alternado.
+     */
+    toggleDropMenu(itemId) {
+        this.expandedDropMenus = Object.assign(Object.assign({}, this.expandedDropMenus), { [itemId]: !this.expandedDropMenus[itemId] });
+    }
+    /**
+     * Recolhe todos os folders do nível 0, exceto o especificado.
+     * Garante que apenas um folder possa estar expandido por vez no comportamento acordeão.
+     *
+     * @param activeItemId - ID do folder que deve permanecer expandido
+     */
+    collapseOtherFolders(activeItemId) {
+        // Encontra todos os menu-list no nível 0
+        const level0MenuLists = this.el.querySelectorAll('br-menu-list[menu-level="0"]');
+        level0MenuLists.forEach((menuList) => {
+            const element = menuList;
+            const itemId = element.getAttribute('data-menu-id');
+            // Se é um folder diferente do ativo, força o recolhimento
+            if (itemId && itemId !== activeItemId) {
+                // Força o estado recolhido no menu-list
+                ;
+                element.expanded = false;
+                // Remove do estado de expandedDropMenus
+                if (this.expandedDropMenus[itemId]) {
+                    this.expandedDropMenus = Object.assign(Object.assign({}, this.expandedDropMenus), { [itemId]: false });
+                }
+            }
+        });
+    }
+    /**
+     * Navega para um nível específico do menu (drill-down).
+     *
+     * Este método é chamado quando o usuário interage com um item de menu de nível 2 ou superior,
+     * ou seja, quando o comportamento esperado é de drill-down (aprofundamento em submenus).
+     *
+     * Funcionamento:
+     * 1. Adiciona o item atual à pilha de navegação (`navigationStack`), permitindo que o usuário volte para níveis anteriores.
+     * 2. Obtém o nível do menu a partir do atributo `menu-level` do elemento clicado.
+     * 3. Atualiza o estado `currentLevel` para refletir o novo nível de profundidade (sempre um nível abaixo do atual).
+     * 4. Define `inSubmenu` como `true`, indicando que o usuário está navegando em um submenu.
+     * 5. Oculta todos os itens do menu, exceto o submenu selecionado, para garantir foco e clareza na navegação.
+     * 6. Marca o elemento ativo como "drill active" para controle visual e de acessibilidade.
+     *
+     * @param item - Objeto contendo o elemento do menu, seu rótulo e identificador único.
+     */
+    navigateToLevel(item) {
+        // Adiciona o item à pilha de navegação para possibilitar o retorno (back)
+        this.navigationStack.push(item);
+        // Obtém o nível do menu a partir do atributo do elemento
+        const menuLevel = parseInt(item.element.getAttribute('menu-level') || '0', 10);
+        // Atualiza o nível atual para o próximo nível após o elemento clicado
+        this.currentLevel = menuLevel + 1;
+        // Indica que estamos em um submenu (drill-down ativo)
+        this.inSubmenu = true;
+        // Oculta todos os menus, exceto o submenu selecionado
+        this.hideAllExcept(item.element);
+        // Marca o submenu como ativo para controle visual e de acessibilidade
+        this.setDrillActive(item.element, true);
+        // Após entrar no submenu, foca no primeiro item visível
+        const rafId = requestAnimationFrame(() => this.focusFirstChildOfList(item.element));
+        this.rafIds.push(rafId);
+    }
+    focusFirstChildOfList(listEl) {
+        var _a, _b, _c, _d, _e;
+        const slotEl = (_a = listEl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('ul slot');
+        const assigned = ((_b = slotEl === null || slotEl === void 0 ? void 0 : slotEl.assignedElements) === null || _b === void 0 ? void 0 : _b.call(slotEl)) || [];
+        for (const el of assigned) {
+            if (el.tagName === 'BR-MENU-ITEM') {
+                const anchor = (_c = el.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('a');
+                if (this.isVisibleElement(el) && this.isVisibleElement(anchor)) {
+                    anchor.focus();
+                    return;
+                }
+            }
+            else if (el.tagName === 'BR-MENU-LIST') {
+                const header = (_d = el.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('br-menu-item');
+                const anchor = (_e = header === null || header === void 0 ? void 0 : header.shadowRoot) === null || _e === void 0 ? void 0 : _e.querySelector('a');
+                if (this.isVisibleElement(el) && this.isVisibleElement(anchor)) {
+                    anchor.focus();
+                    return;
+                }
+            }
+        }
+    }
+    toggleMenu() {
+        this.active = !this.active;
+        if (this.active) {
+            // Armazena o elemento que estava com foco antes de abrir o menu
+            this.previouslyFocusedElement = this.getDeepActiveElement();
+            // Foca no primeiro elemento visível do menu
+            const rafId = requestAnimationFrame(() => this.focusFirstVisibleTarget());
+            this.rafIds.push(rafId);
+        }
+        else {
+            // Se está fechando, chama closeMenu para fazer a limpeza completa
+            this.closeMenu();
+        }
+    }
+    closeMenu() {
+        this.active = false;
+        this.inSubmenu = false;
+        this.resetNavigation();
+        // Restaura o foco para o elemento que estava focado antes do menu abrir
+        if (this.previouslyFocusedElement) {
+            const rafId = requestAnimationFrame(() => {
+                var _a;
+                (_a = this.previouslyFocusedElement) === null || _a === void 0 ? void 0 : _a.focus();
+                this.previouslyFocusedElement = null;
+            });
+            this.rafIds.push(rafId);
+        }
+        else {
+            // Se não há elemento anterior, foca no botão toggle
+            const rafId = requestAnimationFrame(() => {
+                var _a, _b, _c;
+                const toggleButton = this.contextual
+                    ? (_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('#contextual-trigger')
+                    : (_b = this.el.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('#toggle-menu');
+                if (toggleButton) {
+                    const button = (_c = toggleButton.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('button');
+                    button === null || button === void 0 ? void 0 : button.focus();
+                }
+            });
+            this.rafIds.push(rafId);
+        }
+    }
+    resetNavigation() {
+        this.navigationStack = [];
+        this.currentLevel = 0;
+        this.expandedDropMenus = {};
+        this.clearAllDrillMarkers();
+        this.showAllMenuItems();
+    }
+    isVisibleElement(el) {
+        var _a;
+        if (el == null)
+            return false;
+        const htmlEl = el;
+        if (!htmlEl.isConnected)
+            return false;
+        if (htmlEl.hasAttribute('hidden'))
+            return false;
+        const rects = (_a = htmlEl.getClientRects) === null || _a === void 0 ? void 0 : _a.call(htmlEl);
+        return rects != null && rects.length > 0;
+    }
+    getTopLevelTargets() {
+        var _a, _b, _c, _d, _e;
+        const targets = [];
+        const bodySlot = (_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('nav.menu-body slot:not([name])');
+        const children = ((_b = bodySlot === null || bodySlot === void 0 ? void 0 : bodySlot.assignedElements) === null || _b === void 0 ? void 0 : _b.call(bodySlot)) || [];
+        for (const child of children) {
+            if (child.tagName === 'BR-MENU-ITEM') {
+                if (!this.isVisibleElement(child))
+                    continue;
+                const anchor = (_c = child.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('a');
+                if (this.isVisibleElement(anchor))
+                    targets.push(anchor);
+            }
+            else if (child.tagName === 'BR-MENU-LIST') {
+                if (!this.isVisibleElement(child))
+                    continue;
+                const header = (_d = child.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('br-menu-item');
+                const anchor = (_e = header === null || header === void 0 ? void 0 : header.shadowRoot) === null || _e === void 0 ? void 0 : _e.querySelector('a');
+                if (this.isVisibleElement(anchor))
+                    targets.push(anchor);
+            }
+        }
+        return targets;
+    }
+    /**
+     * Obtém todos os elementos navegáveis visíveis no menu, incluindo itens dentro de agrupamentos expandidos.
+     * Utilizado para navegação global por setas no modo contextual.
+     */
+    getAllVisibleTargets() {
+        var _a, _b;
+        const targets = [];
+        const bodySlot = (_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('nav.menu-body slot:not([name])');
+        const children = ((_b = bodySlot === null || bodySlot === void 0 ? void 0 : bodySlot.assignedElements) === null || _b === void 0 ? void 0 : _b.call(bodySlot)) || [];
+        for (const child of children) {
+            this.collectVisibleTargetsFrom(child, targets);
+        }
+        return targets;
+    }
+    /**
+     * Coleta recursivamente todos os targets visíveis de um elemento e seus descendentes.
+     * Respeita o estado expandido/recolhido dos agrupamentos.
+     */
+    collectVisibleTargetsFrom(element, targets) {
+        var _a, _b, _c, _d, _e;
+        if (element.tagName === 'BR-MENU-ITEM') {
+            if (!this.isVisibleElement(element))
+                return;
+            const anchor = (_a = element.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('a');
+            if (this.isVisibleElement(anchor)) {
+                targets.push(anchor);
+            }
+        }
+        else if (element.tagName === 'BR-MENU-LIST') {
+            if (!this.isVisibleElement(element))
+                return;
+            // Adiciona o header do menu-list
+            const header = (_b = element.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('br-menu-item');
+            const headerAnchor = (_c = header === null || header === void 0 ? void 0 : header.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('a');
+            if (this.isVisibleElement(headerAnchor)) {
+                targets.push(headerAnchor);
+            }
+            // Verifica se o menu-list está expandido antes de processar os filhos
+            const menuListEl = element;
+            const isExpanded = menuListEl.expanded || menuListEl.hasAttribute('expanded');
+            if (isExpanded) {
+                // Verifica também se o <ul> está realmente visível (para nível 0 que usa display:none)
+                const ulElement = (_d = element.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('ul');
+                const isUlVisible = ulElement ? this.isVisibleElement(ulElement) : false;
+                if (isUlVisible) {
+                    // Coleta os filhos do slot do menu-list
+                    const slotEl = ulElement.querySelector('slot');
+                    const assigned = ((_e = slotEl === null || slotEl === void 0 ? void 0 : slotEl.assignedElements) === null || _e === void 0 ? void 0 : _e.call(slotEl)) || [];
+                    for (const child of assigned) {
+                        this.collectVisibleTargetsFrom(child, targets);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Obtém targets com escopo limitado ao menu-list mais próximo (usado em drill-down).
+     */
+    getScopedTargets(deepActive) {
+        const listScope = this.findClosestMenuListFrom(deepActive);
+        return listScope ? this.getTargetsForMenuList(listScope) : this.getTopLevelTargets();
+    }
+    isNodeWithinHost(node) {
+        let current = node;
+        while (current != null) {
+            if (current === this.el)
+                return true;
+            if (current instanceof Element && current.parentElement != null) {
+                current = current.parentElement;
+            }
+            else {
+                const root = current instanceof Element ? current.getRootNode() : current;
+                current = root != null && 'host' in root ? root.host : null;
+            }
+        }
+        return false;
+    }
+    findClosestMenuListFrom(node) {
+        let current = node;
+        while (current != null) {
+            if (current instanceof Element && current.tagName === 'BR-MENU-LIST')
+                return current;
+            if (current instanceof Element && current.parentElement != null) {
+                current = current.parentElement;
+            }
+            else {
+                const root = current instanceof Element ? current.getRootNode() : current;
+                current = root != null && 'host' in root ? root.host : null;
+            }
+        }
+        return null;
+    }
+    getTargetsForMenuList(listEl) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const targets = [];
+        const header = (_a = listEl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('br-menu-item');
+        const headerAnchor = (_b = header === null || header === void 0 ? void 0 : header.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('a');
+        if (this.isVisibleElement(header) && this.isVisibleElement(headerAnchor))
+            targets.push(headerAnchor);
+        const slotEl = (_c = listEl.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('ul slot');
+        const assigned = ((_d = slotEl === null || slotEl === void 0 ? void 0 : slotEl.assignedElements) === null || _d === void 0 ? void 0 : _d.call(slotEl)) || [];
+        for (const el of assigned) {
+            if (el.tagName === 'BR-MENU-ITEM') {
+                const anchor = (_e = el.shadowRoot) === null || _e === void 0 ? void 0 : _e.querySelector('a');
+                if (this.isVisibleElement(el) && this.isVisibleElement(anchor))
+                    targets.push(anchor);
+            }
+            else if (el.tagName === 'BR-MENU-LIST') {
+                const subHeader = (_f = el.shadowRoot) === null || _f === void 0 ? void 0 : _f.querySelector('br-menu-item');
+                const subAnchor = (_g = subHeader === null || subHeader === void 0 ? void 0 : subHeader.shadowRoot) === null || _g === void 0 ? void 0 : _g.querySelector('a');
+                if (this.isVisibleElement(el) && this.isVisibleElement(subAnchor))
+                    targets.push(subAnchor);
+            }
+        }
+        return targets;
+    }
+    focusFirstVisibleTarget() {
+        const targets = this.getTopLevelTargets();
+        if (targets.length > 0)
+            targets[0].focus();
+    }
+    /**
+     * Coleta recursivamente os elementos focáveis no modo drill-down.
+     * Respeita a ordem do DOM e a hierarquia dos elementos.
+     * Apenas coleta elementos que não têm o atributo 'hidden'.
+     */
+    collectDrillDownTargets(element, targets) {
+        var _a, _b, _c;
+        const children = Array.from(element.children);
+        for (const child of children) {
+            if (child.hasAttribute('hidden'))
+                continue;
+            if (!this.isVisibleElement(child))
+                continue;
+            if (child.tagName === 'BR-MENU-ITEM') {
+                const anchor = (_a = child.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('a');
+                if (anchor && this.isVisibleElement(anchor)) {
+                    targets.push(anchor);
+                }
+            }
+            else if (child.tagName === 'BR-MENU-LIST') {
+                // Adiciona o header do menu-list
+                const header = (_b = child.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('br-menu-item');
+                const headerAnchor = (_c = header === null || header === void 0 ? void 0 : header.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('a');
+                if (headerAnchor && this.isVisibleElement(headerAnchor)) {
+                    targets.push(headerAnchor);
+                }
+                // Coleta recursivamente os filhos do menu-list
+                this.collectDrillDownTargets(child, targets);
+            }
+            else {
+                // Para outros elementos, continua a busca recursiva
+                this.collectDrillDownTargets(child, targets);
+            }
+        }
+    }
+    /**
+     * Obtém todos os elementos focáveis dentro do menu que estão visíveis.
+     * Inclui botões, links e outros elementos interativos.
+     * No modo contextual, inclui itens dentro de agrupamentos expandidos.
+     */
+    getFocusableElements() {
+        var _a, _b, _c, _d, _e;
+        const focusable = [];
+        const menuPanel = (_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.menu-panel');
+        if (!menuPanel)
+            return focusable;
+        // Adiciona o botão trigger (toggle/contextual) como primeiro elemento com foco
+        const triggerButton = this.contextual
+            ? (_b = this.el.shadowRoot) === null || _b === void 0 ? void 0 : _b.querySelector('#contextual-trigger')
+            : (_c = this.el.shadowRoot) === null || _c === void 0 ? void 0 : _c.querySelector('#toggle-menu');
+        if (triggerButton) {
+            const button = (_d = triggerButton.shadowRoot) === null || _d === void 0 ? void 0 : _d.querySelector('button');
+            if (button && this.isVisibleElement(button)) {
+                focusable.push(button);
+            }
+        }
+        // Busca o botão de voltar se estiver em submenu
+        const backButton = (_e = this.el.shadowRoot) === null || _e === void 0 ? void 0 : _e.querySelector('.back-btn');
+        if (backButton && this.isVisibleElement(backButton)) {
+            focusable.push(backButton);
+        }
+        // No modo contextual ou quando não há drill-down, usa navegação global que respeita estado expandido
+        if (this.contextual || !this.inSubmenu) {
+            const targets = this.getAllVisibleTargets();
+            focusable.push(...targets);
+        }
+        else {
+            // Em drill-down, coleta elementos na ordem do DOM respeitando a hierarquia
+            // O método hideAllExcept() já controla a visibilidade via atributo 'hidden'
+            this.collectDrillDownTargets(this.el, focusable);
+        }
+        return focusable;
+    }
+    // Navegação por setas é tratada via listener global de teclado
+    getDeepActiveElement(root = document) {
+        const active = root.activeElement;
+        const shadowRoot = active && 'shadowRoot' in active ? active.shadowRoot : null;
+        if (shadowRoot && shadowRoot.activeElement)
+            return this.getDeepActiveElement(shadowRoot);
+        return active;
+    }
+    /**
+     * Oculta todos os elementos do menu, exceto o elemento ativo e sua cadeia de ancestrais,
+     * garantindo que apenas o submenu relevante esteja visível durante a navegação drill-down.
+     *
+     * Funcionamento detalhado:
+     * 1. Oculta todos os elementos <br-menu-list> e <br-menu-item> do menu, aplicando o atributo 'hidden'.
+     *    Isso garante que nada além do caminho de navegação atual fique visível.
+     * 2. Remove o atributo 'drill-ancestor' de quaisquer listas marcadas anteriormente, limpando o estado visual.
+     * 3. Remove o atributo 'hidden' do elemento ativo (o submenu ou item selecionado), tornando-o visível.
+     * 4. Percorre a cadeia de ancestrais do elemento ativo:
+     *    - Para cada ancestral do tipo <br-menu-list> ou <br-menu-item>, remove o 'hidden' para garantir visibilidade.
+     *    - Para ancestrais <br-menu-list> (exceto o próprio ativo), adiciona o atributo 'drill-ancestor' para permitir
+     *      estilização diferenciada (por exemplo, ocultar cabeçalhos mas manter o conteúdo visível).
+     *    - Interrompe o loop ao chegar no elemento host do componente.
+     * 5. Exibe todos os filhos diretos do elemento ativo que sejam <br-menu-list> ou <br-menu-item>,
+     *    removendo o 'hidden' para mostrar as opções do submenu.
+     * 6. Exibe também filhos que estejam dentro de um <ul> (estrutura comum em subníveis),
+     *    garantindo que todos os itens relevantes do submenu estejam visíveis.
+     *
+     * Este método é fundamental para a experiência de navegação drill-down, pois controla
+     * exatamente quais partes do menu são exibidas ao usuário em cada etapa da navegação.
+     *
+     * @param activeElement O elemento <br-menu-list> ou <br-menu-item> que representa o submenu/item atualmente ativo.
+     */
+    hideAllExcept(activeElement) {
+        // 1. Oculta todos os elementos do menu
+        const allMenuElements = this.el.querySelectorAll('br-menu-list, br-menu-item');
+        allMenuElements.forEach((element) => {
+            ;
+            element.setAttribute('hidden', '');
+        });
+        // 2. Limpa marcadores de ancestrais anteriores
+        this.el.querySelectorAll('br-menu-list[drill-ancestor]').forEach((e) => {
+            ;
+            e.removeAttribute('drill-ancestor');
+        });
+        // 3. Garante que o elemento ativo esteja visível
+        activeElement.removeAttribute('hidden');
+        // 4. Exibe a cadeia de ancestrais do elemento ativo
+        let ancestor = activeElement.parentElement;
+        while (ancestor !== null) {
+            const tag = ancestor.tagName;
+            if (tag === 'BR-MENU-LIST' || tag === 'BR-MENU-ITEM') {
+                ancestor.removeAttribute('hidden');
+            }
+            if (tag === 'BR-MENU-LIST' && ancestor !== activeElement) {
+                ancestor.setAttribute('drill-ancestor', '');
+            }
+            if (ancestor === this.el)
+                break;
+            ancestor = ancestor.parentElement;
+        }
+        // 5. Exibe filhos diretos do elemento ativo
+        const directChildren = activeElement.querySelectorAll(':scope > br-menu-list, :scope > br-menu-item');
+        directChildren.forEach((child) => {
+            ;
+            child.removeAttribute('hidden');
+        });
+        // 6. Exibe filhos dentro de <ul> do elemento ativo
+        const listChildren = activeElement.querySelectorAll(':scope > ul br-menu-list, :scope > ul br-menu-item');
+        listChildren.forEach((child) => {
+            ;
+            child.removeAttribute('hidden');
+        });
+    }
+    /**
+     * Exibe todos os itens e listas do menu, removendo o atributo 'hidden' de cada um.
+     *
+     * Esta função é utilizada para restaurar a visualização completa do menu,
+     * normalmente após uma navegação drill-down ou ao retornar ao nível raiz.
+     *
+     * O método percorre todos os elementos <br-menu-list> e <br-menu-item> dentro do componente
+     * e garante que estejam visíveis, removendo o atributo 'hidden' que pode ter sido
+     * adicionado durante a navegação entre submenus.
+     */
+    showAllMenuItems() {
+        const allMenuLists = this.el.querySelectorAll('br-menu-list');
+        const allMenuItems = this.el.querySelectorAll('br-menu-item');
+        allMenuLists.forEach((menuList) => {
+            ;
+            menuList.removeAttribute('hidden');
+        });
+        allMenuItems.forEach((menuItem) => {
+            ;
+            menuItem.removeAttribute('hidden');
+        });
+    }
+    /**
+     * Marca ou desmarca um elemento <br-menu-list> como ativo no contexto de navegação drill-down.
+     *
+     * Quando 'active' é true, adiciona o atributo 'drill-active' ao elemento, indicando que
+     * ele está no foco da navegação. Quando 'active' é false, remove esse atributo.
+     *
+     * Esse atributo pode ser utilizado para aplicar estilos visuais ou lógica condicional
+     * durante a navegação entre níveis do menu.
+     *
+     * @param element Elemento <br-menu-list> a ser marcado/desmarcado
+     * @param active Boolean indicando se o elemento deve ser marcado como ativo
+     */
+    setDrillActive(element, active) {
+        if (active) {
+            element.setAttribute('drill-active', '');
+        }
+        else {
+            element.removeAttribute('drill-active');
+        }
+    }
+    /**
+     * Remove todos os marcadores de navegação drill-down do menu.
+     *
+     * Esta função percorre todos os elementos <br-menu-list> que possuem os atributos
+     * 'drill-active' ou 'drill-ancestor' e remove esses atributos. Isso é necessário
+     * para garantir que, ao retornar ao nível raiz ou reiniciar a navegação, nenhum
+     * marcador visual ou lógico de navegação anterior permaneça ativo.
+     */
+    clearAllDrillMarkers() {
+        // Remove o atributo 'drill-active' de todos os <br-menu-list>
+        this.el.querySelectorAll('br-menu-list[drill-active]').forEach((e) => {
+            ;
+            e.removeAttribute('drill-active');
+        });
+        // Remove o atributo 'drill-ancestor' de todos os <br-menu-list>
+        this.el.querySelectorAll('br-menu-list[drill-ancestor]').forEach((e) => {
+            ;
+            e.removeAttribute('drill-ancestor');
+        });
+    }
+    /**
+     * Realiza a navegação de retorno (voltar) em menus do tipo drill-down.
+     *
+     * Esta função é chamada quando o usuário deseja voltar um nível na navegação do menu.
+     * Ela utiliza uma pilha de navegação (navigationStack) para controlar o histórico de navegação.
+     *
+     * - Se houver elementos na pilha, remove o elemento do topo (nível atual) e desmarca como ativo.
+     * - Se, após a remoção, a pilha estiver vazia, significa que o usuário retornou ao nível raiz:
+     *   - Restaura o estado inicial do menu, mostrando todos os itens e limpando marcadores de navegação.
+     * - Caso contrário, ativa o elemento do nível anterior e oculta os demais, mantendo o contexto do drill-down.
+     */
+    goBack() {
+        if (this.navigationStack.length > 0) {
+            // Remove o elemento do topo da pilha (nível atual)
+            const removed = this.navigationStack.pop();
+            if (removed !== undefined)
+                this.setDrillActive(removed.element, false);
+            if (this.navigationStack.length === 0) {
+                // Se a pilha está vazia, voltamos ao nível raiz do menu
+                this.currentLevel = 0;
+                this.inSubmenu = false;
+                this.clearAllDrillMarkers();
+                this.showAllMenuItems();
+            }
+            else {
+                // Caso ainda haja elementos na pilha, voltamos ao nível anterior do drill-down
+                const previousElement = this.navigationStack[this.navigationStack.length - 1].element;
+                const previousLevel = parseInt(previousElement.getAttribute('menu-level') || '0', 10);
+                // Atualiza o nível atual para refletir o contexto correto
+                this.currentLevel = previousLevel + 1;
+                // Marca o elemento anterior como ativo
+                this.setDrillActive(previousElement, true);
+                // Oculta todos os itens, exceto o submenu ativo
+                this.hideAllExcept(previousElement);
+            }
+        }
+    }
+    /**
+     * Verifica se um slot específico possui conteúdo.
+     */
+    hasSlotContent(slotName) {
+        return this.el.querySelector(`[slot="${slotName}"]`) !== null;
+    }
+    getEffectiveBreakpoints() {
+        // Se o usuário definiu explicitamente, respeita o valor
+        if (this.breakpoints && this.breakpoints.trim() !== '')
+            return this.breakpoints.trim();
+        // Não aplicar breakpoints para o modo contextual para evitar que ele se torne uma barra lateral em telas maiores.
+        if (this.contextual) {
+            return '';
+        }
+        // O padrão para menu flutuante é não ter breakpoints, a menos que o usuário especifique.
+        return '';
+    }
+    getCssClassMap() {
+        const effective = this.getEffectiveBreakpoints();
+        return Object.assign({ 'br-menu': true, active: this.active, push: this.push, contextual: this.contextual, large: this.density === 'large', small: this.density === 'small' }, (effective ? effective.split(' ').reduce((acc, bp) => (Object.assign(Object.assign({}, acc), { [bp]: true })), {}) : {}));
+    }
+    /**
+     * Retorna as classes CSS para o painel do menu.
+     * Aplica breakpoints apenas quando o menu NÃO está no modo push ou contextual.
+     */
+    getMenuPanelClasses() {
+        const baseClass = 'menu-panel';
+        // No modo push ou contextual, não aplica breakpoints
+        if (this.push || this.contextual) {
+            return baseClass;
+        }
+        // Nos outros modos, aplica os breakpoints responsivos
+        const breakpoints = this.getEffectiveBreakpoints();
+        return breakpoints ? `${baseClass} ${breakpoints}` : baseClass;
+    }
+    render() {
+        return (h(Host, { key: 'dc433ee9679e6d3658991f1d3a921da7c1fc8dbe' }, h("div", { key: '424c81d5ed7b576ad3588e451063fa65ce580f70', class: this.getCssClassMap() }, !this.contextual && (h("br-button", { key: '9581d584a026cbd91069fa38ea4518306d33a322', id: "toggle-menu", shape: "circle", density: "small", "aria-label": "Menu", onClick: this.handleToggleMenu }, h("br-icon", { key: '383cb09f823db7b46079a6a77399e3ffd5bebeb9', "icon-name": `fa6-solid:bars`, "aria-hidden": "true" }))), this.contextual && (h("div", { key: '5756be1c8f87d7d29af305178ff868e63aca8ccf', class: "menu-trigger" }, h("br-button", { key: 'ed120bf2d3e647925e573852afd1ae8778147ca4', id: "contextual-trigger", emphasis: "primary", shape: "block", "aria-label": this.contextualLabel, "aria-expanded": String(this.active), "aria-controls": "contextual-menu-panel", onClick: this.handleToggleMenu }, h("span", { key: 'ef74a127c6a2861945e64968d84623ad707ffc11', class: "trigger-label" }, this.contextualLabel), h("br-icon", { key: '99456da11e2132b96341d78affaf9669224393f3', "icon-name": `fa6-solid:chevron-${this.active ? 'down' : 'up'}`, class: "trigger-icon", "aria-hidden": "true" })))), h("div", { key: '27fd28bb50b6e4753b87e50032010063695ec319', class: 'menu-container' }, h("div", { key: '8a7c9e105e23cfbbe00d6afedf06b752aebe4cb9', id: this.contextual ? 'contextual-menu-panel' : undefined, class: this.getMenuPanelClasses() }, !this.contextual && this.hasSlotContent('header') && h("slot", { key: 'cd80c2e9b7a714203d781ed52b1c455d512a53ab', name: "header" }), h("nav", { key: 'fd55ccb07b30cf7acd4386a1daf4f63da5212421', class: "menu-body" }, this.inSubmenu && this.currentLevel > 0 && (h("div", { key: 'be4d46b2893cf52351c59287650ca29327fd4fb9', class: "menu-back-button" }, h("button", { key: 'd747cc47a0b52dff0d7478325d50649bf6cc8cce', class: "back-btn", onClick: this.handleGoBack, "aria-label": "Voltar ao n\u00EDvel anterior" }, h("br-icon", { key: 'b46935e70497c4362d56b1c4938990badcf626f0', class: "back-icon", "icon-name": "fa6-solid:angle-left", "aria-hidden": "true" }), h("span", { key: 'ac5766c92caa17ba12c849a83b0f2181b2760c4e', class: "back-title" }, this.navigationStack.length > 0
+            ? `${this.navigationStack[this.navigationStack.length - 1].label}`
+            : ''), this.navigationStack.length > 0 && (h("span", { key: 'ba4ee408387c63e0ae07eb1b083f5bc42dfc606c', class: "current-icon", "aria-hidden": "true" }, h("br-icon", { key: '9512d98ca5c0f87161968667ae6ec21084c81658', "icon-name": `fa6-solid:${this.navigationStack[this.navigationStack.length - 1].element.getAttribute('icon') || 'bars'}` })))))), h("slot", { key: '306675bb2fa2f45e25ac1ea8f52f58f34cb1927b' })), !this.contextual && (h("div", { key: 'e816587dee2f7407509ac8953b0be125aceb98f5', class: "menu-footer", part: "footer" }, this.hasSlotContent('logo') && (h("div", { key: 'a182ecefc91c5d012b80a76d48dc4699aed61d3d', class: "menu-logos", part: "logo" }, h("slot", { key: '33fc108075057678980a9818f91c4b7b67e55539', name: "logo" }))), this.hasSlotContent('link') && (h("div", { key: 'bb4d761ad39879e6aa7ba1f903ecef254c8f7350', class: "menu-links", part: "link" }, h("slot", { key: 'b5e002bd663f20c0a48b9de66a356d5a1bda154a', name: "link" }))), this.hasSlotContent('social') && (h("div", { key: 'b033f48137a84cbf0cfdfbe47c869e96d650659a', class: "social-network", part: "social" }, this.socialTitle && h("div", { key: 'fa35c93d090e6e69fe2e3499f2f2e98c4181f64e', class: "social-network-title" }, this.socialTitle), h("div", { key: '2f4e268f09256c345f5c828c40e708f65341a346', class: "sharegroup" }, h("slot", { key: '0b5df8caef454336393eba151b0257fb22efaf78', name: "social" })))), this.hasSlotContent('info') && (h("div", { key: '6457d37c96afee1b6eaf83ebefb9de32831c56b6', class: "menu-info", part: "info" }, h("slot", { key: '5e529e0b6603060f704b0bc9248ea2c8e326cd3e', name: "info" })))))), this.active && h("div", { key: 'e3213ed68204e856f72952b834581e6aabef84af', class: "menu-scrim", onClick: this.handleCloseMenu })))));
+    }
+    static get is() { return "br-menu"; }
+    static get encapsulation() { return "shadow"; }
+    static get formAssociated() { return true; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["menu.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["menu.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "breakpoints": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'col-sm-4 col-lg-3'"
+                        }],
+                    "text": "Classes CSS para definir breakpoints responsivos do menu.\nUtilize esta propriedade para controlar a largura do menu em diferentes tamanhos de tela."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "breakpoints",
+                "defaultValue": "''"
+            },
+            "push": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Define se o menu deve usar comportamento push (sempre vis\u00EDvel em telas maiores).\nQuando ativado, o menu permanece fixo na lateral e empurra o conte\u00FAdo principal."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "push",
+                "defaultValue": "false"
+            },
+            "contextual": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Define se o menu deve usar comportamento contextual (aparece na parte inferior).\nQuando ativado, o menu \u00E9 posicionado na parte inferior da tela em dispositivos m\u00F3veis."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "contextual",
+                "defaultValue": "false"
+            },
+            "density": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "'large' | 'medium' | 'small'",
+                    "resolved": "\"large\" | \"medium\" | \"small\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'medium'"
+                        }],
+                    "text": "Define a densidade dos itens do menu, alterando o espa\u00E7amento interno.\n- `small` (densidade alta): itens mais compactos\n- `medium` (padr\u00E3o): equil\u00EDbrio entre economia de espa\u00E7o e separa\u00E7\u00E3o\n- `large` (densidade baixa): maior espa\u00E7amento (recomendado em touch)"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "density",
+                "defaultValue": "'medium'"
+            },
+            "socialTitle": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Redes Sociais'"
+                        }],
+                    "text": "T\u00EDtulo da se\u00E7\u00E3o de redes sociais exibida no rodap\u00E9 do menu.\nUtilize esta propriedade para personalizar o texto que aparece acima dos \u00EDcones sociais."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "social-title",
+                "defaultValue": "'Redes Sociais'"
+            },
+            "contextualLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Menu Contextual'"
+                        }],
+                    "text": "R\u00F3tulo do bot\u00E3o trigger do menu contextual.\nExibido apenas em modo contextual e em telas menores (mobile)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "contextual-label",
+                "defaultValue": "'Menu Contextual'"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "active": {},
+            "inSubmenu": {},
+            "currentLevel": {},
+            "expandedDropMenus": {},
+            "navigationStack": {}
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get listeners() {
+        return [{
+                "name": "click",
+                "method": "handleMenuItemClick",
+                "target": undefined,
+                "capture": true,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "handleKeyDown",
+                "target": "window",
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "navigateToSubmenu",
+                "method": "handleNavigateToSubmenu",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "folderToggled",
+                "method": "handleFolderToggled",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brMenuHeaderClose",
+                "method": "handleMenuHeaderClose",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}
+//# sourceMappingURL=menu.js.map