@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/collection/components/modal/modal.js

@@ -0,0 +1,842 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h } from "@stencil/core";
+import { captureFocus, restoreFocus } from "../../shared/utils/focus";
+import { generateUniqueId } from "../../shared/utils/id";
+import { syncNativeModalDialog } from "../../shared/utils/native-dialog";
+/**
+ * Para a documentação completa, incluindo diretrizes de uso, acessibilidade e exemplos visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/modal?tab=designer).
+ *
+ * @slot header - Cabeçalho do modal. Se não for usado, o `title-text` será exibido.
+ * @slot default - Corpo do modal.
+ * @slot footer - Rodapé do modal.
+ * @slot close-button - Botão de fechar customizado. Se não for usado, o botão padrão será exibido.
+ *
+ * @category Feedback
+ * @status stable
+ * @part container - Wrapper principal do modal.
+ * @part header - Cabeçalho do modal.
+ * @part title - Título do modal.
+ * @part body - Corpo do modal.
+ * @part footer - Rodapé do modal.
+ * @part close-button - Botão de fechar do modal.
+ *
+ */
+export class Modal {
+    constructor() {
+        /**
+         * Identificador único do componente.
+         * Quando omitido, um valor é gerado automaticamente.
+         *
+         * > **Padrão:** valor único gerado por generateUniqueId().
+         *
+         */
+        this.customId = generateUniqueId();
+        /** Controla a visibilidade do modal. */
+        this.show = false;
+        /**
+         * Define o comportamento de fechamento do modal.
+         *
+         * - `true`: O modal fecha automaticamente ao clicar no botão fechar.
+         * - `false`: O modal emite `brModalBeforeClose` mas não fecha, permitindo a implementação de lógica customizada (validação, confirmação, etc.) antes do fechamento. O desenvolvedor deve
+         *   controlar manualmente o fechamento.
+         */
+        this.autoClose = false;
+        /**
+         * Define o tamanho (largura) do modal.
+         */
+        this.size = 'medium';
+        /**
+         * Se `true`, habilita a rolagem interna do conteúdo do modal.
+         */
+        this.scrollable = false;
+        /**
+         * Define o alinhamento do conteúdo do rodapé (slot="footer").
+         */
+        this.alignFooter = 'center';
+        this.isOpeningParentScrim = false;
+        this.triggerElement = null;
+        this.pendingFocus = false;
+        this.nativeDialogRef = null;
+        this.keyListenerAttached = false;
+        /**
+         * TECLADO
+         *
+         * Manipuladores e utilitários relacionados à interação por teclado,
+         * incluindo tratamento de `Escape` para fechar o modal e navegação por
+         * `Tab`/`Shift+Tab` para manter o foco preso (focus trap) dentro do modal.
+         */
+        this.handleKeyDown = (event) => {
+            if (!this.show)
+                return;
+            if (this.usesStandaloneDialog)
+                return;
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                event.stopPropagation();
+                this.brModalBeforeClose.emit();
+                if (this.el.dispatchEvent(new globalThis.Event('cancel', { cancelable: true })))
+                    this.show = false;
+                return;
+            }
+            if (event.key === 'Tab') {
+                this.handleTabNavigation(event);
+            }
+        };
+        /**
+         * Handler para evento brScrimOpen do parent scrim
+         * Quando scrim abre programaticamente, a modal deve abrir também
+         */
+        this.handleParentScrimOpen = () => {
+            const parentScrim = this.el.closest('br-scrim');
+            if (parentScrim === null)
+                return;
+            if (!this.show) {
+                this.show = true;
+            }
+        };
+        /**
+         * Handler para evento brScrimClose do parent scrim
+         * Se autoClose=true, fecha a modal junto com o scrim
+         * Se autoClose=false, não faz nada (modal permanece aberta)
+         */
+        this.handleParentScrimClose = () => {
+            const parentScrim = this.el.closest('br-scrim');
+            if (parentScrim === null)
+                return;
+            if (this.autoClose && this.show) {
+                this.show = false;
+            }
+        };
+        this.handleClose = () => {
+            this.brModalBeforeClose.emit();
+            const closeRequested = this.el.dispatchEvent(new globalThis.Event('cancel', { cancelable: true }));
+            if (this.autoClose && closeRequested) {
+                this.show = false;
+            }
+        };
+        this.handleNativeCancel = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            this.brModalBeforeClose.emit();
+            if (this.el.dispatchEvent(new globalThis.Event('cancel', { cancelable: true })))
+                this.show = false;
+        };
+    }
+    handleShowChange(newValue, oldValue) {
+        if (newValue) {
+            this.attachKeyListener();
+            this.triggerElement = captureFocus(this.el.ownerDocument);
+            this.brModalOpen.emit();
+            this.openParentScrim();
+            requestAnimationFrame(() => this.moveFocusIntoModal());
+        }
+        else if (oldValue === true) {
+            this.detachKeyListener();
+            syncNativeModalDialog(this.nativeDialogRef, false);
+            this.brModalClose.emit();
+            this.el.dispatchEvent(new globalThis.Event('close'));
+            this.closeParentScrim();
+            restoreFocus(this.triggerElement);
+            this.triggerElement = null;
+        }
+    }
+    disconnectedCallback() {
+        syncNativeModalDialog(this.nativeDialogRef, false);
+        this.isOpeningParentScrim = false;
+        this.removeParentScrimEventListeners();
+        this.detachKeyListener();
+    }
+    componentWillLoad() {
+        if (!this.show) {
+            const parentScrim = this.el.closest('br-scrim');
+            if (parentScrim?.isOpen) {
+                this.show = true;
+            }
+        }
+    }
+    componentDidLoad() {
+        this.listenToParentScrimEvents();
+        if (this.show) {
+            this.openParentScrim();
+            requestAnimationFrame(() => this.moveFocusIntoModal());
+        }
+        if (this.show)
+            this.attachKeyListener();
+    }
+    componentDidRender() {
+        if (this.show && this.usesStandaloneDialog)
+            syncNativeModalDialog(this.nativeDialogRef, true);
+        if (this.pendingFocus && this.show) {
+            this.pendingFocus = false;
+            this.moveFocusIntoModal();
+        }
+    }
+    attachKeyListener() {
+        if (this.keyListenerAttached)
+            return;
+        document.addEventListener('keydown', this.handleKeyDown, true);
+        this.keyListenerAttached = true;
+    }
+    detachKeyListener() {
+        if (!this.keyListenerAttached)
+            return;
+        document.removeEventListener('keydown', this.handleKeyDown, true);
+        this.keyListenerAttached = false;
+    }
+    /**
+     * MÉTODOS PÚBLICOS (API)
+     *
+     * Métodos públicos expostos pela API do componente (`open`, `close`, etc.).
+     */
+    /**
+     * Método público para abrir o modal
+     */
+    async open() {
+        this.show = true;
+        this.openParentScrim();
+    }
+    /** Abre o modal usando a nomenclatura de `HTMLDialogElement`. */
+    async showModal() {
+        await this.open();
+    }
+    /**
+     * Método público para fechar o modal
+     */
+    async close() {
+        this.show = false;
+    }
+    /** Solicita fechamento e permite cancelamento pelo evento `cancel`. */
+    async requestClose() {
+        this.brModalBeforeClose.emit();
+        if (this.el.dispatchEvent(new globalThis.Event('cancel', { cancelable: true })))
+            await this.close();
+    }
+    /**
+     * Método público para alternar a visibilidade do modal
+     */
+    async toggle() {
+        this.show = !this.show;
+    }
+    /**
+     * UTILITÁRIOS
+     *
+     * Getters e helpers utilitários usados internamente pelo componente,
+     * como geração de IDs e mapeamento de classes CSS.
+     */
+    get titleId() {
+        return `${this.customId}-title`;
+    }
+    get contentId() {
+        return `${this.customId}-content`;
+    }
+    /**
+     * GERENCIAMENTO DE FOCO
+     *
+     * Métodos responsáveis por mover o foco para dentro do modal, estabilizar o
+     * foco em elementos iniciais e localizar elementos nativos focáveis dentro
+     * de web components que utilizam Shadow DOM.
+     */
+    async moveFocusIntoModal() {
+        await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+        if (!this.show)
+            return;
+        const root = this.el.shadowRoot;
+        if (root === null)
+            return;
+        const modal = root.querySelector('.br-modal');
+        if (modal !== null) {
+            modal.focus();
+            modal.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        }
+        if (typeof this.initialFocusSelector === 'string' && this.initialFocusSelector !== '') {
+            const target = await this.waitForElement(this.initialFocusSelector);
+            if (target !== null) {
+                const focusTarget = this.findDeepNativeFocusable(target) ?? target;
+                focusTarget.focus();
+                target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+            }
+        }
+        this.brModalOpened.emit();
+    }
+    /**
+     * Encontra recursivamente o primeiro elemento nativo focável dentro de um elemento,
+     * perfurando shadow roots aninhados em qualquer profundidade (ex: br-select → br-input → <input>).
+     *
+     * @returns O elemento nativo encontrado, ou null se nenhum for encontrado.
+     */
+    findDeepNativeFocusable(el) {
+        const root = el.shadowRoot;
+        if (root === null)
+            return null;
+        // Busca direta no shadow imediato, por ordem de prioridade
+        const prioritySelectors = [
+            'input:not([disabled])',
+            'select:not([disabled])',
+            'textarea:not([disabled])',
+            'button:not([disabled])',
+            'a[href]',
+        ];
+        for (const sel of prioritySelectors) {
+            const found = root.querySelector(sel);
+            if (found !== null)
+                return found;
+        }
+        // Nenhum nativo direto — procurar em custom elements filhos que também tenham shadow
+        // (ex: br-select.shadow → br-input → br-input.shadow → <input>)
+        const customChildren = Array.from(root.querySelectorAll('*')).filter((child) => child.tagName.includes('-') && child.shadowRoot !== null);
+        for (const child of customChildren) {
+            const inner = this.findDeepNativeFocusable(child);
+            if (inner !== null)
+                return inner;
+        }
+        return null;
+    }
+    /**
+     * Aguarda o elemento aparecer no DOM e estar pronto para receber foco.
+     * Tenta por até 10 vezes com intervalos de 50ms (500ms total).
+     */
+    waitForElement(selector, retries = 10, interval = 50) {
+        return new Promise((resolve) => {
+            const attempt = (remaining) => {
+                const el = document.querySelector(selector);
+                if (el !== null) {
+                    // Se for custom element, aguarda upgrade antes de resolver
+                    const tag = el.tagName.toLowerCase();
+                    if (tag.includes('-')) {
+                        customElements.whenDefined(tag).then(() => resolve(el));
+                    }
+                    else {
+                        resolve(el);
+                    }
+                    return;
+                }
+                if (remaining <= 0) {
+                    resolve(null);
+                    return;
+                }
+                setTimeout(() => attempt(remaining - 1), interval);
+            };
+            attempt(retries);
+        });
+    }
+    /**
+     * Implementa o focus trap circular dentro da modal.
+     * Quando Tab é pressionado no último elemento focalizável, o foco vai para o primeiro.
+     * Quando Shift+Tab é pressionado no primeiro, o foco vai para o último.
+     *
+     * Usa `composedPath()[0]` para obter o elemento real com foco, pois web components
+     * com shadow DOM retornam o host via `document.activeElement`, não o elemento nativo interno.
+     *
+     * Usa `findDeepNativeFocusable` no wrap porque `host.focus()` é no-op em web components
+     * sem `delegatesFocus` — focar o elemento nativo mais profundo garante que o wrap aconteça.
+     */
+    handleTabNavigation(event) {
+        const focusable = this.getFocusableElements();
+        if (focusable.length === 0) {
+            event.preventDefault();
+            return;
+        }
+        const first = focusable[0];
+        const last = focusable[focusable.length - 1];
+        const activeEl = (event.composedPath?.()[0] ?? document.activeElement);
+        const firstTarget = this.findDeepNativeFocusable(first) ?? first;
+        const lastTarget = this.findDeepNativeFocusable(last) ?? last;
+        if (!event.shiftKey && this.isOrInsideElement(activeEl, last)) {
+            event.preventDefault();
+            firstTarget.focus();
+        }
+        else if (event.shiftKey && this.isOrInsideElement(activeEl, first)) {
+            event.preventDefault();
+            lastTarget.focus();
+        }
+    }
+    /**
+     * Verifica se `target` é igual a `container` ou está dentro dele,
+     * perfurando shadow roots na subida (getRootNode().host).
+     */
+    isOrInsideElement(target, container) {
+        if (target === container)
+            return true;
+        let node = target;
+        while (node !== null && node !== document) {
+            if (node === container)
+                return true;
+            const root = node.getRootNode();
+            if (root instanceof ShadowRoot) {
+                node = root.host;
+            }
+            else {
+                node = node.parentElement;
+                if (node === null)
+                    break;
+            }
+        }
+        return false;
+    }
+    /**
+     * Coleta todos os elementos focalizáveis dentro da modal,
+     * perfurando o shadow DOM: inclui elementos do shadow root (ex: botão fechar)
+     * e dos slots (conteúdo fornecido pelo usuário nos slots header, default, footer e close-button).
+     */
+    getFocusableElements() {
+        const root = this.el.shadowRoot;
+        if (root === null)
+            return [];
+        const selector = Modal.FOCUSABLE_SELECTORS;
+        const elements = [];
+        // Elementos focalizáveis diretamente no shadow root (ex: br-button.close)
+        root.querySelectorAll(selector).forEach((el) => {
+            elements.push(el);
+        });
+        // Elementos dos slots (conteúdo do usuário)
+        root.querySelectorAll('slot').forEach((slot) => {
+            slot.assignedElements({ flatten: true }).forEach((assigned) => {
+                if (!(assigned instanceof HTMLElement))
+                    return;
+                if (assigned.matches(selector))
+                    elements.push(assigned);
+                assigned.querySelectorAll(selector).forEach((el) => {
+                    elements.push(el);
+                });
+            });
+        });
+        // Remove referências duplicadas e filtra elementos não visíveis.
+        // Retorna apenas elementos realmente focáveis e perceptíveis ao usuário.
+        return Array.from(new Set(elements)).filter((el) => el.offsetWidth > 0 && el.offsetHeight > 0 && getComputedStyle(el).visibility !== 'hidden');
+    }
+    /**
+     * INTEGRAÇÃO COM BR-SCRIM
+     *
+     * Métodos para integrar o comportamento do modal com um `br-scrim` pai,
+     * incluindo abertura/fechamento sincronizados e listeners para eventos do
+     * scrim.
+     */
+    closeParentScrim() {
+        const parentScrim = this.el.closest('br-scrim');
+        if (parentScrim && typeof parentScrim.close === 'function') {
+            parentScrim.close();
+        }
+    }
+    get usesStandaloneDialog() {
+        return this.el.closest('br-scrim') === null;
+    }
+    /**
+     * Adiciona listeners para eventos do parent scrim
+     */
+    listenToParentScrimEvents() {
+        const parentScrim = this.el.closest('br-scrim');
+        if (parentScrim !== null) {
+            parentScrim.addEventListener('brScrimOpen', this.handleParentScrimOpen);
+            parentScrim.addEventListener('brScrimClose', this.handleParentScrimClose);
+        }
+    }
+    /**
+     * Remove listeners de eventos do parent scrim
+     */
+    removeParentScrimEventListeners() {
+        const parentScrim = this.el.closest('br-scrim');
+        if (parentScrim !== null) {
+            parentScrim.removeEventListener('brScrimOpen', this.handleParentScrimOpen);
+            parentScrim.removeEventListener('brScrimClose', this.handleParentScrimClose);
+        }
+    }
+    openParentScrim() {
+        if (this.isOpeningParentScrim)
+            return;
+        const parentScrim = this.el.closest('br-scrim');
+        if (parentScrim && !parentScrim.isOpen) {
+            this.isOpeningParentScrim = true;
+            Promise.resolve()
+                .then(() => {
+                try {
+                    return parentScrim.open();
+                }
+                catch (error) {
+                    console.warn('br-modal: Erro ao abrir scrim pai:', error);
+                    throw error;
+                }
+            })
+                .finally(() => {
+                this.isOpeningParentScrim = false;
+            });
+        }
+    }
+    getCssClassMap() {
+        return {
+            'br-modal': true,
+            [this.size]: true,
+            scrollable: this.scrollable,
+        };
+    }
+    render() {
+        if (!this.show) {
+            return null;
+        }
+        const ModalContainer = this.usesStandaloneDialog ? 'dialog' : 'div';
+        return (h(Host, null, h(ModalContainer, { ref: (element) => {
+                this.nativeDialogRef = this.usesStandaloneDialog ? element : null;
+            }, class: this.getCssClassMap(), role: this.usesStandaloneDialog ? undefined : 'dialog', tabIndex: -1, "aria-modal": "true", "aria-labelledby": this.titleId, "aria-describedby": this.contentId, part: "container", onCancel: this.usesStandaloneDialog ? this.handleNativeCancel : undefined }, h("div", { class: "br-modal-header", part: "header" }, h("div", { class: "modal-title", id: this.titleId, part: "title" }, h("slot", { name: "header" }, this.titleText)), h("slot", { name: "close-button" }, h("br-button", { part: "close-button", class: "close", shape: "circle", density: "small", "prop:ariaLabel": "Fechar", onClick: this.handleClose }, h("br-icon", { iconName: "fa-solid:times", width: "16", height: "16" })))), h("div", { id: this.contentId, class: "br-modal-body", part: "body" }, h("slot", null)), h("div", { class: `br-modal-footer ${this.alignFooter !== undefined ? `justify-content-${this.alignFooter}` : ''}`, part: "footer" }, h("slot", { name: "footer" })))));
+    }
+    static get is() { return "br-modal"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["modal.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["modal.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 do componente.\nQuando omitido, um valor \u00E9 gerado automaticamente.\n\n> **Padr\u00E3o:** valor \u00FAnico gerado por generateUniqueId()."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "custom-id",
+                "defaultValue": "generateUniqueId()"
+            },
+            "titleText": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "O texto do t\u00EDtulo a ser exibido no cabe\u00E7alho do modal. Usado quando o slot `header` n\u00E3o \u00E9 fornecido."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "title-text"
+            },
+            "show": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Controla a visibilidade do modal."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "show",
+                "defaultValue": "false"
+            },
+            "autoClose": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o comportamento de fechamento do modal.\n\n- `true`: O modal fecha automaticamente ao clicar no bot\u00E3o fechar.\n- `false`: O modal emite `brModalBeforeClose` mas n\u00E3o fecha, permitindo a implementa\u00E7\u00E3o de l\u00F3gica customizada (valida\u00E7\u00E3o, confirma\u00E7\u00E3o, etc.) antes do fechamento. O desenvolvedor deve\n  controlar manualmente o fechamento."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "auto-close",
+                "defaultValue": "false"
+            },
+            "initialFocusSelector": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Seletor CSS do elemento que deve receber foco quando o modal \u00E9 aberto (ex: `\"#meu-elemento\"`)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "initial-focus-selector"
+            },
+            "size": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "ModalSize",
+                    "resolved": "\"auto\" | \"large\" | \"medium\" | \"small\" | \"xsmall\"",
+                    "references": {
+                        "ModalSize": {
+                            "location": "import",
+                            "path": "./modal.types",
+                            "id": "src/components/modal/modal.types.ts::ModalSize",
+                            "referenceLocation": "ModalSize"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o tamanho (largura) do modal."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "size",
+                "defaultValue": "'medium'"
+            },
+            "scrollable": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Se `true`, habilita a rolagem interna do conte\u00FAdo do modal."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "scrollable",
+                "defaultValue": "false"
+            },
+            "alignFooter": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "ModalFooterAlign",
+                    "resolved": "\"center\" | \"end\" | \"start\"",
+                    "references": {
+                        "ModalFooterAlign": {
+                            "location": "import",
+                            "path": "./modal.types",
+                            "id": "src/components/modal/modal.types.ts::ModalFooterAlign",
+                            "referenceLocation": "ModalFooterAlign"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o alinhamento do conte\u00FAdo do rodap\u00E9 (slot=\"footer\")."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "align-footer",
+                "defaultValue": "'center'"
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "brModalOpen",
+                "name": "brModalOpen",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento emitido quando o modal \u00E9 aberto (quando `show` muda de `false` para `true`)."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brModalClose",
+                "name": "brModalClose",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento emitido ap\u00F3s o modal ser fechado (quando `show` muda de `true` para `false`)."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brModalBeforeClose",
+                "name": "brModalBeforeClose",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento emitido antes do fechamento do modal (quando o bot\u00E3o X \u00E9 clicado).\nSe autoClose est\u00E1 desativado, o desenvolvedor deve fechar manualmente o modal ap\u00F3s este evento.\nSe autoClose est\u00E1 ativado, o modal fecha automaticamente ap\u00F3s este evento."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "brModalOpened",
+                "name": "brModalOpened",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento emitido ap\u00F3s o modal estar completamente aberto e com o foco estabilizado\ndentro dele. Complementa `brModalOpen` (que dispara imediatamente ao abrir):\nuse `brModalOpened` quando precisar interagir com o modal j\u00E1 pronto."
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "open": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "M\u00E9todo p\u00FAblico para abrir o modal",
+                    "tags": []
+                }
+            },
+            "showModal": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Abre o modal usando a nomenclatura de `HTMLDialogElement`.",
+                    "tags": []
+                }
+            },
+            "close": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "M\u00E9todo p\u00FAblico para fechar o modal",
+                    "tags": []
+                }
+            },
+            "requestClose": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Solicita fechamento e permite cancelamento pelo evento `cancel`.",
+                    "tags": []
+                }
+            },
+            "toggle": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "M\u00E9todo p\u00FAblico para alternar a visibilidade do modal",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "show",
+                "methodName": "handleShowChange"
+            }];
+    }
+}
+Modal.FOCUSABLE_SELECTORS = [
+    'a[href]:not([disabled])',
+    'button:not([disabled])',
+    'br-button:not([disabled]):not([tabindex="-1"])',
+    'input:not([disabled])',
+    'br-input:not([disabled]):not([tabindex="-1"])',
+    'select:not([disabled])',
+    'br-select:not([disabled]):not([tabindex="-1"])',
+    'textarea:not([disabled])',
+    'br-textarea:not([disabled]):not([tabindex="-1"])',
+    '[tabindex]:not([tabindex="-1"])',
+].join(',');