@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/collection/components/pagination/pagination.js

@@ -0,0 +1,1470 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { Host, h, } from "@stencil/core";
+import Helpers from "../../shared/utils/helpers";
+/**
+ * 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/pagination?tab=designer).
+ *
+ * @category Navegação
+ * @status stable
+ *
+ * @slot pagination-info - Informação customizada da paginação contextual. Quando utilizado, o texto padrão de contagem é substituído.
+ * @slot loading - Indicador exibido enquanto uma página é carregada.
+ *
+ * @part nav - Parte para o contêiner raiz da paginação (elemento nav), usada para estilização via ::part().
+ * @part list - Parte para a lista de páginas (elemento ul), usada para estilização via ::part().
+ * @part page - Parte para os itens de página numérica (elemento a), usada para estilização via ::part().
+ * @part ellipsis - Parte para o botão de reticências e seu contêiner.
+ * @part ellipsis-button - Parte encaminhada do botão de reticências.
+ * @part per-page - Parte para o seletor de itens por página na variante contextual.
+ * @part per-page-container - Contêiner encaminhado do seletor de itens por página.
+ * @part per-page-input - Campo encaminhado do seletor de itens por página.
+ * @part per-page-list - Lista encaminhada do seletor de itens por página.
+ * @part go-to - Parte para o seletor de navegação direta na variante contextual.
+ * @part go-to-container - Contêiner encaminhado do seletor de navegação direta.
+ * @part go-to-input - Campo encaminhado do seletor de navegação direta.
+ * @part go-to-list - Lista encaminhada do seletor de navegação direta.
+ * @part prev-button - Parte para o botão de página anterior, usada para estilização via ::part().
+ * @part prev-button-inner - Botão interno encaminhado da página anterior.
+ * @part next-button - Parte para o botão de próxima página, usada para estilização via ::part().
+ * @part next-button-inner - Botão interno encaminhado da próxima página.
+ * @part loading - Área do indicador de carregamento.
+ */
+export class Pagination {
+    constructor() {
+        /**
+         * Estado interno para responsividade. Verdadeiro quando viewport < sm.
+         */
+        this.isSmall = false;
+        /** Materializa as opções completas somente após a primeira abertura do seletor. */
+        this.goToOptionsReady = false;
+        this.goToSearchTerm = '';
+        /**
+         * Controla a janela visível de cada dropdown de reticências.
+         */
+        this.ellipsisScrollOffsets = {};
+        /**
+         * Altura efetiva dos itens do dropdown de reticências.
+         * O valor fixo é usado somente até a primeira medição válida do DOM.
+         */
+        this.ellipsisItemHeight = Pagination.ELLIPSIS_ITEM_HEIGHT_FALLBACK;
+        /**
+         * Identificador único do componente.
+         * Quando omitido, um valor é gerado automaticamente.
+         *
+         * > **Padrão:** valor único gerado por Helpers.generateUniqueId().
+         *
+         * > **Uso compartilhado:** mantenha esta descrição idêntica em todos os componentes que usam `customId`.
+         */
+        this.customId = Helpers.generateUniqueId();
+        /**
+         * Quantidade total de páginas (mínimo 1).
+         */
+        this.total = 1;
+        /**
+         * Página atual (1-indexada). Valores fora do intervalo serão ajustados.
+         */
+        this.current = 1;
+        /**
+         * Rótulo acessível do botão de página anterior.
+         */
+        this.previousLabel = 'Voltar página';
+        /**
+         * Rótulo acessível do botão de próxima página.
+         */
+        this.nextLabel = 'Página seguinte';
+        /**
+         * Rótulo acessível do botão de reticências que abre a lista de páginas ocultas.
+         */
+        this.ellipsisLabel = 'Abrir ou fechar a lista de paginação';
+        /**
+         * Define a densidade visual do componente.
+         *
+         * - `small`: Alta densidade (componente menor, mais compacto e com menos espaçamento).
+         * - `medium`: Densidade intermediária, padrão recomendado para a maioria dos casos.
+         * - `large`: Baixa densidade (componente maior, mais espaçamento e altura).
+         *
+         * > **Uso compartilhado:** mantenha esta descrição idêntica em todos os componentes que usam `density`.
+         */
+        this.density = 'medium';
+        /**
+         * Variante de renderização do componente.
+         * - `default`: paginação numérica (padrão)
+         * - `contextual`: paginação contextual com seletores e informação de itens
+         */
+        this.variant = 'default';
+        /**
+         * Mantém `current` e `perPage` sob controle da aplicação.
+         *
+         * Quando ativo, interações apenas emitem a intenção de mudança. A aplicação
+         * deve atualizar a propriedade correspondente após concluir seu processamento.
+         *
+         * @default false
+         */
+        this.controlled = false;
+        /** Indica que a página solicitada ainda está sendo carregada pelo consumidor.
+         * @default false
+         */
+        this.loading = false;
+        /**
+         * Itens por página (aplicável na variante contextual).
+         */
+        this.perPage = 10;
+        /**
+         * Opções disponíveis de itens por página (variante contextual).
+         */
+        this.perPageOptions = [10, 20, 30];
+        /**
+         * Rótulo do seletor de itens por página (variante contextual).
+         */
+        this.perPageLabel = 'Exibir';
+        /**
+         * Rótulo do seletor "ir para página" (variante contextual).
+         */
+        this.goToPageLabel = 'Página';
+        /**
+         * Sufixo textual para a informação de quantidade de itens (variante contextual).
+         */
+        this.itemsText = 'itens';
+        this.ellipsisScrollFrame = null;
+        this.pendingEllipsisScrollOffsets = {};
+        this.pendingEllipsisFocus = null;
+        this.goToOptionsCache = null;
+        this.pendingGoToResetFrame = null;
+        this.goTo = (page) => {
+            if (this.loading)
+                return;
+            const next = this.clampPage(page);
+            if (next !== this.current) {
+                if (!this.controlled) {
+                    this.current = next;
+                    if (this.currentPage !== undefined)
+                        this.currentPage = next;
+                }
+                this.pageChange.emit({ page: next });
+                this.brPaginationPageChange.emit({ page: next });
+            }
+            // Gerenciar foco após mudanças iniciadas pelo usuário
+            this.queueFocusAfterNavigation();
+        };
+        this.handlePrevClick = (event) => {
+            event.preventDefault();
+            if (this.current > 1) {
+                this.goTo(this.current - 1);
+            }
+        };
+        this.handleNextClick = (event) => {
+            event.preventDefault();
+            const maxPages = this.variant === 'contextual' ? this.getTotalPages() : this.getDefaultTotalPages();
+            if (this.current < maxPages) {
+                this.goTo(this.current + 1);
+            }
+        };
+        this.handlePageClickFactory = (page) => {
+            return (event) => {
+                event.preventDefault();
+                if (this.loading)
+                    return;
+                this.lastInteraction = 'number';
+                this.goTo(page);
+            };
+        };
+        this.handleEllipsisItemClickFactory = (page) => {
+            return () => {
+                if (this.loading)
+                    return;
+                this.lastInteraction = 'ellipsis';
+                this.goTo(page);
+            };
+        };
+        this.handlePageKeyDown = (ev) => {
+            const target = ev.target;
+            // Aceita tanto o botão de página quanto o botão de reticências
+            if (!(target?.matches('button.page[part="page"]') || target?.matches('.pagination-ellipsis br-button[slot="trigger"]'))) {
+                return;
+            }
+            const buttons = this.getVisiblePageButtons();
+            const idx = buttons.indexOf(target);
+            if (idx === -1)
+                return;
+            switch (ev.key) {
+                case 'ArrowRight':
+                case 'ArrowDown':
+                    ev.preventDefault();
+                    this.focusPageButtonByIndex(idx + 1);
+                    break;
+                case 'ArrowLeft':
+                case 'ArrowUp':
+                    ev.preventDefault();
+                    this.focusPageButtonByIndex(idx - 1);
+                    break;
+                case 'Home':
+                    ev.preventDefault();
+                    this.focusPageButtonByIndex(0);
+                    break;
+                case 'End':
+                    ev.preventDefault();
+                    this.focusPageButtonByIndex(buttons.length - 1);
+                    break;
+                default:
+                    break;
+            }
+        };
+        this.handleEllipsisScrollFactory = (key, totalItems) => {
+            return (event) => {
+                const list = event.currentTarget;
+                if (list === null)
+                    return;
+                this.pendingEllipsisScrollOffsets[key] = list.scrollTop;
+                if (this.ellipsisScrollFrame !== null)
+                    return;
+                this.ellipsisScrollFrame = requestAnimationFrame(() => {
+                    this.ellipsisScrollFrame = null;
+                    const offsets = this.pendingEllipsisScrollOffsets;
+                    this.pendingEllipsisScrollOffsets = {};
+                    Object.entries(offsets).forEach(([offsetKey, scrollTop]) => {
+                        this.setEllipsisScrollOffset(offsetKey, scrollTop, totalItems);
+                    });
+                });
+            };
+        };
+        this.handleEllipsisItemKeyDownFactory = (key, totalItems) => {
+            return (event) => {
+                const item = event.currentTarget;
+                const pageIndex = Number(item?.getAttribute('data-page-index'));
+                if (item === null || !Number.isInteger(pageIndex))
+                    return;
+                if (event.key === 'Escape') {
+                    event.preventDefault();
+                    event.stopImmediatePropagation();
+                    this.handleEllipsisEscape(item, key);
+                    return;
+                }
+                this.handleEllipsisBoundaryNavigation(event, key, totalItems, pageIndex);
+            };
+        };
+        this.handlePerPageChange = (event) => {
+            if (this.loading)
+                return;
+            const value = Number(event.detail);
+            // Ignora se o valor não for um número finito ou não tiver mudado
+            if (!Number.isFinite(value) || value === this.perPage) {
+                return;
+            }
+            const nextPerPage = Math.max(1, value);
+            if (!this.controlled) {
+                this.perPage = nextPerPage;
+                this.current = this.clampPage(this.current); // Ajusta a página atual
+            }
+            const detail = { perPage: nextPerPage };
+            this.perPageChange.emit(detail);
+            this.brPaginationPerPageChange.emit(detail);
+            // Gerencia o foco após a interação
+            this.lastInteraction = 'perPage';
+            this.queueFocusAfterNavigation();
+        };
+        this.handleGoToPageChange = (event) => {
+            if (this.loading)
+                return;
+            const value = Number(event.detail);
+            if (this.pendingGoToPage !== undefined)
+                return;
+            // O fallback para this.current garante que não tentemos navegar para NaN.
+            const next = this.clampPage(Number.isFinite(value) ? value : this.current);
+            if (next !== this.current) {
+                this.lastInteraction = 'goTo';
+                this.pendingGoToPage = next;
+                if (this.pendingGoToResetFrame !== null)
+                    cancelAnimationFrame(this.pendingGoToResetFrame);
+                this.pendingGoToResetFrame = requestAnimationFrame(() => {
+                    this.pendingGoToResetFrame = null;
+                    this.pendingGoToPage = undefined;
+                });
+                this.goTo(next);
+            }
+        };
+        this.handleGoToSelectOpened = () => {
+            if (this.goToOptionsReady)
+                return;
+            this.goToOptionsReady = true;
+        };
+    }
+    handleTotalChange() {
+        this.goToOptionsCache = null;
+        this.goToOptionsReady = false;
+        this.resetAllEllipsisScrollOffsets();
+        this.current = this.clampPage(this.current);
+    }
+    handleTotalPagesChange(newValue) {
+        this.goToOptionsCache = null;
+        this.goToOptionsReady = false;
+        if (newValue !== undefined && newValue !== this.total)
+            this.total = newValue;
+    }
+    handleCurrentChange(newValue) {
+        this.resetAllEllipsisScrollOffsets();
+        const clamped = this.clampPage(newValue);
+        if (clamped !== newValue) {
+            this.current = clamped;
+        }
+        if (this.currentPage !== undefined && this.currentPage !== clamped)
+            this.currentPage = clamped;
+    }
+    handleCurrentPageChange(newValue) {
+        if (newValue !== undefined && newValue !== this.current)
+            this.current = newValue;
+    }
+    handlePerPagePropChange(newValue) {
+        this.goToOptionsCache = null;
+        this.goToOptionsReady = false;
+        if (this.variant !== 'contextual')
+            return;
+        const nextPerPage = Math.max(1, Number(newValue) || 1);
+        if (nextPerPage !== newValue) {
+            this.perPage = nextPerPage;
+            return;
+        }
+        this.current = this.clampPage(this.current);
+    }
+    handleTotalItemsChange() {
+        this.goToOptionsCache = null;
+        this.goToOptionsReady = false;
+        if (this.variant !== 'contextual')
+            return;
+        this.current = this.clampPage(this.current);
+    }
+    handleDensityChange() {
+        this.ellipsisScrollOffsets = {};
+        this.pendingEllipsisFocus = null;
+        this.ellipsisItemHeight = this.computeItemHeightForDensity();
+    }
+    connectedCallback() {
+        this.setupMediaQuery();
+    }
+    disconnectedCallback() {
+        this.cleanupMediaQuery();
+        this.pendingEllipsisFocus = null;
+        if (this.ellipsisScrollFrame !== null) {
+            cancelAnimationFrame(this.ellipsisScrollFrame);
+            this.ellipsisScrollFrame = null;
+        }
+        if (this.pendingGoToResetFrame !== null) {
+            cancelAnimationFrame(this.pendingGoToResetFrame);
+            this.pendingGoToResetFrame = null;
+        }
+        this.pendingGoToPage = undefined;
+    }
+    componentWillLoad() {
+        if (this.totalPages !== undefined)
+            this.total = this.totalPages;
+        if (this.currentPage !== undefined)
+            this.current = this.currentPage;
+        this.current = this.clampPage(this.current);
+    }
+    componentDidLoad() {
+        this.ellipsisItemHeight = this.computeItemHeightForDensity();
+    }
+    componentDidRender() {
+        this.flushPendingEllipsisFocus();
+    }
+    /**
+     * Define programaticamente a página atual dentro do intervalo permitido.
+     * @param page Página desejada (1-indexada).
+     * Em `controlled`, emite a solicitação sem alterar `current`.
+     */
+    async setPage(page) {
+        this.goTo(page);
+    }
+    /**
+     * Solicita navegação programática para uma página (1-indexada).
+     * Em `controlled`, aguarda a confirmação externa para alterar `current`.
+     */
+    async goToPage(page) {
+        this.goTo(page);
+    }
+    // Calcula a altura do item com base nos tokens de density do GovBR-DS.
+    // py-3 = spacing-scale-2x (medium), py-4 = spacing-scale-3x (large), base para small.
+    computeItemHeightForDensity() {
+        if (typeof window === 'undefined')
+            return Pagination.ELLIPSIS_ITEM_HEIGHT_FALLBACK;
+        const style = getComputedStyle(this.el);
+        const spacingBase = parseFloat(style.getPropertyValue('--spacing-scale-base'));
+        const fontSize = parseFloat(style.getPropertyValue('--font-size-scale-base'));
+        const lineHeight = parseFloat(style.getPropertyValue('--font-line-height-medium'));
+        if (!Number.isFinite(spacingBase) || !Number.isFinite(fontSize) || !Number.isFinite(lineHeight)) {
+            return Pagination.ELLIPSIS_ITEM_HEIGHT_FALLBACK;
+        }
+        const paddingY = this.density === 'large' ? spacingBase * 3 : this.density === 'medium' ? spacingBase * 2 : spacingBase;
+        return Math.ceil(fontSize * lineHeight + paddingY * 2);
+    }
+    setupMediaQuery() {
+        if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
+            return;
+        const query = '(max-width: 575.98px)';
+        this.cleanupMediaQuery();
+        try {
+            this.mqlSmall = window.matchMedia(query);
+            this.isSmall = this.mqlSmall.matches;
+            this.mqlSmallHandler = (event) => {
+                this.isSmall = event.matches;
+            };
+            const legacyMediaQueryList = this.mqlSmall;
+            if (typeof this.mqlSmall.addEventListener === 'function') {
+                this.mqlSmall.addEventListener('change', this.mqlSmallHandler);
+            }
+            else if (typeof legacyMediaQueryList.addListener === 'function') {
+                legacyMediaQueryList.addListener(this.mqlSmallHandler);
+            }
+        }
+        catch {
+            console.warn(`Media Query "${query}" is not supported in this browser.`);
+            this.mqlSmall = undefined;
+            this.mqlSmallHandler = undefined;
+            this.isSmall = false;
+        }
+    }
+    cleanupMediaQuery() {
+        if (this.mqlSmall === undefined || this.mqlSmallHandler === undefined) {
+            this.mqlSmall = undefined;
+            this.mqlSmallHandler = undefined;
+            return;
+        }
+        if (typeof this.mqlSmall.removeEventListener === 'function') {
+            this.mqlSmall.removeEventListener('change', this.mqlSmallHandler);
+        }
+        else {
+            const legacyMediaQueryList = this.mqlSmall;
+            if (typeof legacyMediaQueryList.removeListener === 'function') {
+                legacyMediaQueryList.removeListener(this.mqlSmallHandler);
+            }
+        }
+        this.mqlSmall = undefined;
+        this.mqlSmallHandler = undefined;
+    }
+    getCssClassMap() {
+        return {
+            'br-pagination': true,
+            small: this.density === 'small',
+            large: this.density === 'large',
+            medium: this.density === 'medium',
+            'dark-mode': this.colorMode === 'dark',
+        };
+    }
+    getDefaultTotalPages() {
+        return Math.max(1, Number(this.totalPages ?? this.total) || 1);
+    }
+    clampPage(value) {
+        const total = this.variant === 'contextual' ? this.getTotalPages() : this.getDefaultTotalPages();
+        const clampedValue = Math.max(1, Number(value) || 1);
+        return Math.min(clampedValue, total);
+    }
+    getVisiblePageButtons() {
+        const root = this.el.shadowRoot;
+        if (root === null)
+            return [];
+        return Array.from(root.querySelectorAll('button.page[part="page"], .pagination-ellipsis br-button[slot="trigger"]'));
+    }
+    focusPageButtonByIndex(index) {
+        const buttons = this.getVisiblePageButtons();
+        if (buttons.length === 0)
+            return;
+        const clamped = Math.max(0, Math.min(index, buttons.length - 1));
+        const btn = buttons[clamped];
+        // Garantir roving tabindex
+        buttons.forEach((b, i) => {
+            b.tabIndex = i === clamped ? 0 : -1;
+        });
+        btn.focus();
+    }
+    queueFocusAfterNavigation() {
+        // Diferir para após renderização (fallback em ambientes sem RAF)
+        const defer = typeof requestAnimationFrame === 'function'
+            ? requestAnimationFrame
+            : (cb) => setTimeout(() => cb(0), 0);
+        defer(() => {
+            if (this.variant === 'contextual') {
+                this.lastInteraction = undefined;
+                return;
+            }
+            // Variant default: focar no botão da página atual ao vir de reticências
+            if (this.lastInteraction === 'ellipsis' || this.lastInteraction === 'number') {
+                const buttons = this.getVisiblePageButtons();
+                const currentBtn = buttons.find((b) => b.getAttribute('aria-current') === 'page');
+                if (currentBtn !== null && currentBtn !== undefined) {
+                    // Roving tabindex: somente o atual recebe 0
+                    buttons.forEach((b) => {
+                        b.tabIndex = b === currentBtn ? 0 : -1;
+                    });
+                    currentBtn.focus();
+                }
+            }
+            this.lastInteraction = undefined;
+        });
+    }
+    getComputedNavAriaLabel() {
+        // Respeita o valor fornecido externamente
+        if (this.ariaLabel && String(this.ariaLabel).trim().length > 0)
+            return this.ariaLabel;
+        const totalPages = this.variant === 'contextual' ? this.getTotalPages() : this.getDefaultTotalPages();
+        return `Paginação: página ${this.current} de ${totalPages}`;
+    }
+    renderPageButton(page) {
+        return (h("li", { key: page }, h("button", { part: "page", class: { page: true, active: page === this.current }, "aria-label": `Página ${page}`, "aria-current": page === this.current ? 'page' : null, type: "button", tabIndex: page === this.current ? 0 : -1, onClick: this.handlePageClickFactory(page), onKeyDown: this.handlePageKeyDown, disabled: this.loading }, page)));
+    }
+    getEllipsisRangeKey(position, from, to) {
+        return `${position}:${from}:${to}`;
+    }
+    resetAllEllipsisScrollOffsets() {
+        this.pendingEllipsisFocus = null;
+        if (Object.keys(this.ellipsisScrollOffsets).length === 0)
+            return;
+        this.ellipsisScrollOffsets = {};
+    }
+    resetEllipsisScrollOffset(key) {
+        if (this.pendingEllipsisFocus?.key === key) {
+            this.pendingEllipsisFocus = null;
+        }
+        if (!(key in this.ellipsisScrollOffsets))
+            return;
+        const nextOffsets = { ...this.ellipsisScrollOffsets };
+        delete nextOffsets[key];
+        this.ellipsisScrollOffsets = nextOffsets;
+    }
+    getEllipsisMetrics(key, totalItems) {
+        const itemHeight = this.ellipsisItemHeight;
+        const safeTotalItems = Math.max(0, totalItems);
+        const shouldVirtualize = safeTotalItems > Pagination.ELLIPSIS_VISIBLE_ITEMS;
+        const visibleItems = Math.min(safeTotalItems, Pagination.ELLIPSIS_VISIBLE_ITEMS);
+        const viewportHeight = visibleItems * itemHeight;
+        const maxScrollTop = Math.max(0, safeTotalItems * itemHeight - viewportHeight);
+        const storedScrollTop = shouldVirtualize ? (this.ellipsisScrollOffsets[key] ?? 0) : 0;
+        const scrollTop = Math.min(Math.max(0, storedScrollTop), maxScrollTop);
+        if (safeTotalItems === 0) {
+            return {
+                shouldVirtualize,
+                visibleItems,
+                scrollTop: 0,
+                renderedStartIndex: 0,
+                renderedEndIndex: -1,
+                viewportHeight,
+            };
+        }
+        const firstVisibleIndex = Math.min(safeTotalItems - 1, Math.floor(scrollTop / itemHeight));
+        const lastVisibleIndex = shouldVirtualize
+            ? Math.min(safeTotalItems - 1, Math.ceil((scrollTop + viewportHeight) / itemHeight) - 1)
+            : safeTotalItems - 1;
+        const renderedStartIndex = shouldVirtualize
+            ? Math.max(0, Math.min(safeTotalItems - 1, firstVisibleIndex - Pagination.ELLIPSIS_OVERSCAN))
+            : 0;
+        const renderedEndIndex = shouldVirtualize
+            ? Math.max(renderedStartIndex, Math.min(safeTotalItems - 1, lastVisibleIndex + Pagination.ELLIPSIS_OVERSCAN))
+            : safeTotalItems - 1;
+        return {
+            shouldVirtualize,
+            visibleItems,
+            scrollTop,
+            renderedStartIndex,
+            renderedEndIndex,
+            viewportHeight,
+        };
+    }
+    setEllipsisScrollOffset(key, scrollTop, totalItems) {
+        const viewportHeight = Math.min(totalItems ?? 0, Pagination.ELLIPSIS_VISIBLE_ITEMS) * this.ellipsisItemHeight;
+        const maxScrollTop = totalItems === undefined
+            ? Number.POSITIVE_INFINITY
+            : Math.max(0, totalItems * this.ellipsisItemHeight - viewportHeight);
+        const nextScrollTop = Math.min(Math.max(0, scrollTop), maxScrollTop);
+        if ((this.ellipsisScrollOffsets[key] ?? 0) === nextScrollTop)
+            return;
+        this.ellipsisScrollOffsets = {
+            ...this.ellipsisScrollOffsets,
+            [key]: nextScrollTop,
+        };
+    }
+    getEllipsisListElement(key) {
+        return (this.el.shadowRoot?.querySelector(`.pagination-ellipsis[data-ellipsis-key="${key}"] br-list`) ?? null);
+    }
+    focusEllipsisItemNow(key, pageIndex) {
+        const item = this.el.shadowRoot?.querySelector(`.pagination-ellipsis[data-ellipsis-key="${key}"] br-item[data-page-index="${pageIndex}"]`);
+        if (item === null || item === undefined)
+            return false;
+        if ('setFocus' in item) {
+            void item.setFocus();
+            return true;
+        }
+        item.focus();
+        return true;
+    }
+    flushPendingEllipsisFocus() {
+        const pendingFocus = this.pendingEllipsisFocus;
+        if (pendingFocus === null)
+            return;
+        const list = this.getEllipsisListElement(pendingFocus.key);
+        if (list === null)
+            return;
+        list.scrollTop = pendingFocus.scrollTop;
+        if (!this.focusEllipsisItemNow(pendingFocus.key, pendingFocus.pageIndex)) {
+            return;
+        }
+        this.pendingEllipsisFocus = null;
+    }
+    ensureEllipsisItemVisible(key, totalItems, pageIndex) {
+        const { scrollTop, viewportHeight } = this.getEllipsisMetrics(key, totalItems);
+        const itemHeight = this.ellipsisItemHeight;
+        const maxScrollTop = Math.max(0, totalItems * itemHeight - viewportHeight);
+        const itemTop = pageIndex * itemHeight;
+        const itemBottom = itemTop + itemHeight;
+        let nextScrollTop = scrollTop;
+        if (itemTop < scrollTop) {
+            nextScrollTop = itemTop;
+        }
+        else if (itemBottom > scrollTop + viewportHeight) {
+            nextScrollTop = itemBottom - viewportHeight;
+        }
+        nextScrollTop = Math.min(Math.max(0, nextScrollTop), maxScrollTop);
+        if (nextScrollTop !== scrollTop) {
+            this.pendingEllipsisFocus = {
+                key,
+                pageIndex,
+                scrollTop: nextScrollTop,
+            };
+            this.setEllipsisScrollOffset(key, nextScrollTop, totalItems);
+            return;
+        }
+        this.focusEllipsisItemNow(key, pageIndex);
+    }
+    getEllipsisBoundaryNavigationIndex(eventKey, pageIndex, totalItems, visibleItems, renderedStartIndex, renderedEndIndex) {
+        if (eventKey === 'Home')
+            return 0;
+        if (eventKey === 'End')
+            return totalItems - 1;
+        if (eventKey === 'PageDown')
+            return Math.min(totalItems - 1, pageIndex + visibleItems);
+        if (eventKey === 'PageUp')
+            return Math.max(0, pageIndex - visibleItems);
+        if (eventKey === 'ArrowDown') {
+            if (pageIndex === totalItems - 1)
+                return pageIndex;
+            if (pageIndex + 1 > renderedEndIndex)
+                return pageIndex + 1;
+        }
+        if (eventKey === 'ArrowUp') {
+            if (pageIndex === 0)
+                return pageIndex;
+            if (pageIndex - 1 < renderedStartIndex)
+                return pageIndex - 1;
+        }
+        return null;
+    }
+    handleEllipsisEscape(item, key) {
+        this.resetEllipsisScrollOffset(key);
+        const dropdown = item.closest('br-dropdown');
+        void dropdown?.hide();
+    }
+    handleEllipsisBoundaryNavigation(event, key, totalItems, pageIndex) {
+        const { visibleItems, renderedStartIndex, renderedEndIndex } = this.getEllipsisMetrics(key, totalItems);
+        const nextIndex = this.getEllipsisBoundaryNavigationIndex(event.key, pageIndex, totalItems, visibleItems, renderedStartIndex, renderedEndIndex);
+        if (nextIndex === null)
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (nextIndex === pageIndex)
+            return;
+        this.ensureEllipsisItemVisible(key, totalItems, nextIndex);
+    }
+    renderEllipsis(from, to, position) {
+        if (to < from)
+            return null;
+        const totalItems = to - from + 1;
+        const key = this.getEllipsisRangeKey(position, from, to);
+        const { shouldVirtualize, renderedStartIndex, renderedEndIndex, viewportHeight } = this.getEllipsisMetrics(key, totalItems);
+        const items = [];
+        for (let pageIndex = renderedStartIndex; pageIndex <= renderedEndIndex; pageIndex++) {
+            const page = from + pageIndex;
+            items.push(h("br-item", { key: `ellipsis-item-${key}-${page}`, "data-page-index": pageIndex, "prop:density": this.density, isButton: true, role: "menuitem", "aria-posinset": pageIndex + 1, "aria-setsize": totalItems, onBrDidClick: this.handleEllipsisItemClickFactory(page), onKeyDown: this.handleEllipsisItemKeyDownFactory(key, totalItems), "aria-label": `Página ${page}` }, page));
+        }
+        const topSpacerHeight = renderedStartIndex * this.ellipsisItemHeight;
+        const bottomSpacerHeight = Math.max(0, totalItems - renderedEndIndex - 1) * this.ellipsisItemHeight;
+        return (h("li", { class: "pagination-ellipsis", part: "ellipsis", key: `ellipsis-${key}`, "data-ellipsis-key": key, "data-ellipsis-position": position }, h("br-dropdown", null, h("br-button", { part: "ellipsis", exportparts: "button: ellipsis-button", slot: "trigger", shape: "circle", type: "button", "prop:ariaLabel": this.ellipsisLabel, tabIndex: -1, disabled: this.loading, onClick: () => {
+                this.resetEllipsisScrollOffset(key);
+            }, onKeyDown: this.handlePageKeyDown }, h("br-icon", { "attr:iconName": "fa6-solid:ellipsis", width: "16", height: "16", "aria-hidden": "true" }), h("span", { class: "visually-hidden" }, this.ellipsisLabel)), h("br-list", { class: { 'has-scroll': shouldVirtualize, 'is-virtualized': shouldVirtualize }, slot: "target", role: "menu", "aria-label": `Páginas ocultas de ${from} até ${to}`, "aria-orientation": "vertical", onScroll: shouldVirtualize ? this.handleEllipsisScrollFactory(key, totalItems) : undefined, style: shouldVirtualize ? { maxHeight: `${viewportHeight}px` } : undefined }, shouldVirtualize && topSpacerHeight > 0 ? (h("div", { class: "pagination-ellipsis-virtual-spacer", role: "presentation", "aria-hidden": "true", style: { height: `${topSpacerHeight}px` } })) : null, items, shouldVirtualize && bottomSpacerHeight > 0 ? (h("div", { class: "pagination-ellipsis-virtual-spacer", role: "presentation", "aria-hidden": "true", style: { height: `${bottomSpacerHeight}px` } })) : null))));
+    }
+    renderPagesSmall(total, current) {
+        const nodes = [];
+        if (total <= 3) {
+            for (let p = 1; p <= total; p++)
+                nodes.push(this.renderPageButton(p));
+            return nodes;
+        }
+        if (current <= 2) {
+            nodes.push(this.renderPageButton(1));
+            nodes.push(this.renderPageButton(2));
+            nodes.push(this.renderEllipsis(3, total - 1, 'start'));
+            nodes.push(this.renderPageButton(total));
+            return nodes;
+        }
+        if (current >= total - 1) {
+            nodes.push(this.renderPageButton(1));
+            nodes.push(this.renderEllipsis(2, total - 2, 'end'));
+            nodes.push(this.renderPageButton(total - 1));
+            nodes.push(this.renderPageButton(total));
+            return nodes;
+        }
+        nodes.push(this.renderPageButton(1));
+        nodes.push(this.renderEllipsis(2, current - 1, 'left'));
+        nodes.push(this.renderPageButton(current));
+        nodes.push(this.renderEllipsis(current + 1, total - 1, 'right'));
+        nodes.push(this.renderPageButton(total));
+        return nodes;
+    }
+    renderPagesStandard(total, current) {
+        const nodes = [];
+        if (total <= 7) {
+            for (let p = 1; p <= total; p++)
+                nodes.push(this.renderPageButton(p));
+            return nodes;
+        }
+        if (current <= 4) {
+            for (let p = 1; p <= 4; p++)
+                nodes.push(this.renderPageButton(p));
+            nodes.push(this.renderEllipsis(5, total - 1, 'start'));
+            nodes.push(this.renderPageButton(total));
+            return nodes;
+        }
+        if (current >= total - 3) {
+            nodes.push(this.renderPageButton(1));
+            nodes.push(this.renderEllipsis(2, total - 4, 'end'));
+            for (let p = total - 3; p <= total; p++)
+                nodes.push(this.renderPageButton(p));
+            return nodes;
+        }
+        nodes.push(this.renderPageButton(1));
+        nodes.push(this.renderEllipsis(2, current - 2, 'left'));
+        for (let p = current - 1; p <= current + 1; p++)
+            nodes.push(this.renderPageButton(p));
+        nodes.push(this.renderEllipsis(current + 2, total - 1, 'right'));
+        nodes.push(this.renderPageButton(total));
+        return nodes;
+    }
+    renderPages() {
+        const total = this.getDefaultTotalPages();
+        const current = this.clampPage(this.current);
+        return this.isSmall ? this.renderPagesSmall(total, current) : this.renderPagesStandard(total, current);
+    }
+    renderLoading() {
+        if (!this.loading)
+            return null;
+        return (h("span", { part: "loading", class: "pagination-loading", role: "status", "aria-live": "polite", "aria-label": "Carregando" }, h("slot", { name: "loading" }, h("br-loading", { size: "small", compact: true, label: "Carregando" }))));
+    }
+    getTotalPages() {
+        const items = Math.max(0, Number(this.totalItems) || 0);
+        const perPage = Math.max(1, Number(this.perPage) || 1);
+        return Math.max(1, Math.ceil(items / perPage));
+    }
+    getRangeInfo() {
+        const total = Math.max(0, Number(this.totalItems) || 0);
+        const perPage = Math.max(1, Number(this.perPage) || 1);
+        const current = this.clampPage(this.current);
+        if (total === 0)
+            return { start: 0, end: 0, total };
+        const start = (current - 1) * perPage + 1;
+        const end = Math.min(current * perPage, total);
+        return { start, end, total };
+    }
+    handleContextualSelectChange(event) {
+        const select = event
+            .composedPath()
+            .find((node) => node instanceof HTMLElement && node.tagName === 'BR-SELECT');
+        if (!(select instanceof HTMLElement) || select.tagName !== 'BR-SELECT')
+            return;
+        const container = select.parentElement;
+        if (container?.classList.contains('pagination-per-page'))
+            this.handlePerPageChange(event);
+        else if (container?.classList.contains('pagination-go-to-page'))
+            this.handleGoToPageChange(event);
+    }
+    renderPerPageDropdown() {
+        return (h("br-select", { part: "per-page", exportparts: "container: per-page-container, input: per-page-input, input-container: per-page-input-container, input-field: per-page-input-field, input-action: per-page-input-action, list: per-page-list", label: this.perPageLabel, isInline: true, inputWidth: "88px", borderless: true, disabled: this.loading }, this.perPageOptions.map((perPageOption) => (h("br-select-option", { key: String(perPageOption), value: String(perPageOption), selected: perPageOption === this.perPage }, perPageOption)))));
+    }
+    renderPerPageSelect() {
+        return (h("div", { class: "pagination-per-page", part: "per-page" }, this.renderPerPageDropdown()));
+    }
+    renderGoToSelect() {
+        const totalPages = this.getTotalPages();
+        const largePageSet = totalPages > Pagination.LARGE_PAGE_THRESHOLD;
+        const goToInputWidth = `${Math.max(88, String(totalPages).length * 16 + 48)}px`;
+        return (h("div", { class: "pagination-go-to-page d-none d-sm-flex ml-auto" }, h("br-select", { part: "go-to", exportparts: "container: go-to-container, input: go-to-input, input-container: go-to-input-container, input-field: go-to-input-field, input-action: go-to-input-action, list: go-to-list", label: this.goToPageLabel, options: largePageSet
+                ? this.getWindowedGoToOptions(totalPages, this.goToSearchTerm)
+                : this.goToOptionsReady
+                    ? this.getGoToOptions(totalPages)
+                    : this.getCurrentGoToOption(totalPages), onOpened: this.handleGoToSelectOpened, onClosed: () => (this.goToSearchTerm = ''), onBrSelectSearch: (event) => (this.goToSearchTerm = event.detail.query), value: String(this.current), isInline: true, inputWidth: goToInputWidth, "visible-items": 7, filterable: true, searchMode: largePageSet ? 'remote' : 'local', borderless: true, disabled: this.loading })));
+    }
+    getWindowedGoToOptions(totalPages, query) {
+        const parsed = Number.parseInt(query.trim(), 10);
+        const center = Number.isInteger(parsed) && parsed >= 1 && parsed <= totalPages ? parsed : this.current;
+        const radius = query.trim() ? 10 : 50;
+        const pages = new Set([1, totalPages]);
+        if (!query.trim())
+            pages.add(Math.min(Math.max(this.current, 1), totalPages));
+        for (let page = center - radius; page <= center + radius; page++) {
+            if (page >= 1 && page <= totalPages)
+                pages.add(page);
+        }
+        if (query.trim() && (!Number.isInteger(parsed) || parsed < 1 || parsed > totalPages))
+            return [];
+        return [...pages]
+            .sort((a, b) => a - b)
+            .map((page) => ({ value: String(page), label: String(page), selected: page === this.current }));
+    }
+    getCurrentGoToOption(totalPages) {
+        const current = Math.min(Math.max(this.current, 1), totalPages);
+        return [{ value: String(current), label: String(current), selected: true }];
+    }
+    getGoToOptions(totalPages) {
+        if (this.goToOptionsCache !== null && this.goToOptionsCache.length === totalPages) {
+            return this.goToOptionsCache;
+        }
+        this.goToOptionsCache = Array.from({ length: totalPages }, (_, index) => {
+            const page = index + 1;
+            return { value: String(page), label: String(page) };
+        });
+        return this.goToOptionsCache;
+    }
+    renderContextual() {
+        const { start, end, total } = this.getRangeInfo();
+        const totalPages = this.getTotalPages();
+        return (h("nav", { part: "nav", class: this.getCssClassMap(), "aria-busy": this.loading ? 'true' : null, "aria-label": this.getComputedNavAriaLabel(), tabIndex: -1, "data-total": total, "data-current": this.current, "data-per-page": this.perPage, id: this.customId }, this.renderPerPageSelect(), h("span", { class: "br-divider d-none d-sm-block mx-3" }), h("div", { class: "pagination-information d-none d-sm-flex", "aria-live": "polite" }, h("slot", { name: "pagination-info" }, h("span", { class: "current" }, start), "\u2013", h("span", { class: "per-page" }, end), "\u00A0de\u00A0", h("span", { class: "total" }, total), "\u00A0", this.itemsText), this.renderLoading()), this.renderGoToSelect(), h("span", { class: "br-divider d-none d-sm-block mx-3" }), h("div", { class: "pagination-arrows ml-auto ml-sm-0" }, h("br-button", { part: "prev-button", exportparts: "button: prev-button-inner", shape: "circle", density: this.density, type: "button", "data-previous-page": true, "prop:ariaLabel": this.previousLabel, onClick: this.handlePrevClick, disabled: this.loading || this.current <= 1 }, h("br-icon", { "attr:iconName": "fa6-solid:angle-left", width: "16", height: "16", "aria-hidden": "true" }), h("span", { class: "visually-hidden" }, this.previousLabel)), h("br-button", { part: "next-button", exportparts: "button: next-button-inner", shape: "circle", density: this.density, type: "button", "data-next-page": true, "prop:ariaLabel": this.nextLabel, onClick: this.handleNextClick, disabled: this.loading || this.current >= totalPages }, h("br-icon", { "attr:iconName": "fa6-solid:angle-right", width: "16", height: "16", "aria-hidden": "true" }), h("span", { class: "visually-hidden" }, this.nextLabel))), h("span", { class: "visually-hidden", "aria-live": "polite" }, "P\u00E1gina ", this.current, " de ", totalPages)));
+    }
+    render() {
+        if (this.variant === 'contextual') {
+            return h(Host, null, this.renderContextual());
+        }
+        const totalPages = this.getDefaultTotalPages();
+        return (h(Host, null, h("nav", { part: "nav", class: this.getCssClassMap(), "aria-busy": this.loading ? 'true' : null, "aria-label": this.getComputedNavAriaLabel(), tabIndex: -1, "data-total": totalPages, "data-current": this.current, id: this.customId }, h("ul", { part: "list" }, h("li", null, h("br-button", { part: "prev-button", exportparts: "button: prev-button-inner", shape: "circle", density: this.density, type: "button", "data-previous-page": true, "prop:ariaLabel": this.previousLabel, onClick: this.handlePrevClick, disabled: this.loading || this.current <= 1 }, h("br-icon", { "attr:iconName": "fa6-solid:angle-left", width: "16", height: "16", "aria-hidden": "true" }), h("span", { class: "visually-hidden" }, this.previousLabel))), this.renderPages(), this.loading ? (h("li", { part: "loading", class: "pagination-loading" }, this.renderLoading())) : null, h("li", null, h("br-button", { part: "next-button", exportparts: "button: next-button-inner", shape: "circle", density: this.density, type: "button", "data-next-page": true, "prop:ariaLabel": this.nextLabel, onClick: this.handleNextClick, disabled: this.loading || this.current >= totalPages }, h("br-icon", { "attr:iconName": "fa6-solid:angle-right", width: "16", height: "16", "aria-hidden": "true" }), h("span", { class: "visually-hidden" }, this.nextLabel)))), h("span", { class: "visually-hidden", "aria-live": "polite" }, "P\u00E1gina ", this.current, " de ", totalPages))));
+    }
+    static get is() { return "br-pagination"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["pagination.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["pagination.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "colorMode": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "PaginationColorMode",
+                    "resolved": "\"dark\"",
+                    "references": {
+                        "PaginationColorMode": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationColorMode",
+                            "referenceLocation": "PaginationColorMode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Define se a pagina\u00E7\u00E3o usar\u00E1 um esquema de cores escuro.\nQuando definido como `dark`, aplica a classe `dark-mode` ao container principal."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "color-mode"
+            },
+            "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 Helpers.generateUniqueId().\n\n> **Uso compartilhado:** mantenha esta descri\u00E7\u00E3o id\u00EAntica em todos os componentes que usam `customId`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "custom-id",
+                "defaultValue": "Helpers.generateUniqueId()"
+            },
+            "total": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Quantidade total de p\u00E1ginas (m\u00EDnimo 1)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "total",
+                "defaultValue": "1"
+            },
+            "totalPages": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Quantidade total de p\u00E1ginas. Tem preced\u00EAncia sobre `total`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "total-pages"
+            },
+            "current": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "P\u00E1gina atual (1-indexada). Valores fora do intervalo ser\u00E3o ajustados."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "current",
+                "defaultValue": "1"
+            },
+            "currentPage": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "P\u00E1gina atual. Tem preced\u00EAncia sobre `current`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "current-page"
+            },
+            "ariaLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define o r\u00F3tulo acess\u00EDvel usado por tecnologias assistivas.\n\n> **Uso compartilhado:** mantenha esta descri\u00E7\u00E3o id\u00EAntica em todos os componentes que usam `ariaLabel`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "aria-label"
+            },
+            "previousLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "R\u00F3tulo acess\u00EDvel do bot\u00E3o de p\u00E1gina anterior."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "previous-label",
+                "defaultValue": "'Voltar p\u00E1gina'"
+            },
+            "nextLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "R\u00F3tulo acess\u00EDvel do bot\u00E3o de pr\u00F3xima p\u00E1gina."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "next-label",
+                "defaultValue": "'P\u00E1gina seguinte'"
+            },
+            "ellipsisLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "R\u00F3tulo acess\u00EDvel do bot\u00E3o de retic\u00EAncias que abre a lista de p\u00E1ginas ocultas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "ellipsis-label",
+                "defaultValue": "'Abrir ou fechar a lista de pagina\u00E7\u00E3o'"
+            },
+            "density": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "PaginationDensity",
+                    "resolved": "\"large\" | \"medium\" | \"small\"",
+                    "references": {
+                        "PaginationDensity": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationDensity",
+                            "referenceLocation": "PaginationDensity"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Define a densidade visual do componente.\n\n- `small`: Alta densidade (componente menor, mais compacto e com menos espa\u00E7amento).\n- `medium`: Densidade intermedi\u00E1ria, padr\u00E3o recomendado para a maioria dos casos.\n- `large`: Baixa densidade (componente maior, mais espa\u00E7amento e altura).\n\n> **Uso compartilhado:** mantenha esta descri\u00E7\u00E3o id\u00EAntica em todos os componentes que usam `density`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "density",
+                "defaultValue": "'medium'"
+            },
+            "variant": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "PaginationVariant",
+                    "resolved": "\"contextual\" | \"default\"",
+                    "references": {
+                        "PaginationVariant": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationVariant",
+                            "referenceLocation": "PaginationVariant"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Variante de renderiza\u00E7\u00E3o do componente.\n- `default`: pagina\u00E7\u00E3o num\u00E9rica (padr\u00E3o)\n- `contextual`: pagina\u00E7\u00E3o contextual com seletores e informa\u00E7\u00E3o de itens"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "variant",
+                "defaultValue": "'default'"
+            },
+            "controlled": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Mant\u00E9m `current` e `perPage` sob controle da aplica\u00E7\u00E3o.\n\nQuando ativo, intera\u00E7\u00F5es apenas emitem a inten\u00E7\u00E3o de mudan\u00E7a. A aplica\u00E7\u00E3o\ndeve atualizar a propriedade correspondente ap\u00F3s concluir seu processamento."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "controlled",
+                "defaultValue": "false"
+            },
+            "loading": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Indica que a p\u00E1gina solicitada ainda est\u00E1 sendo carregada pelo consumidor."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "loading",
+                "defaultValue": "false"
+            },
+            "totalItems": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Total de itens (aplic\u00E1vel na variante contextual)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "total-items"
+            },
+            "perPage": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Itens por p\u00E1gina (aplic\u00E1vel na variante contextual)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "per-page",
+                "defaultValue": "10"
+            },
+            "perPageOptions": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "number[]",
+                    "resolved": "number[]",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Op\u00E7\u00F5es dispon\u00EDveis de itens por p\u00E1gina (variante contextual)."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[10, 20, 30]"
+            },
+            "perPageLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "R\u00F3tulo do seletor de itens por p\u00E1gina (variante contextual)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "per-page-label",
+                "defaultValue": "'Exibir'"
+            },
+            "goToPageLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "R\u00F3tulo do seletor \"ir para p\u00E1gina\" (variante contextual)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "go-to-page-label",
+                "defaultValue": "'P\u00E1gina'"
+            },
+            "itemsText": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Sufixo textual para a informa\u00E7\u00E3o de quantidade de itens (variante contextual)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "items-text",
+                "defaultValue": "'itens'"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isSmall": {},
+            "goToOptionsReady": {},
+            "goToSearchTerm": {},
+            "ellipsisScrollOffsets": {},
+            "ellipsisItemHeight": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "pageChange",
+                "name": "pageChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Solicita uma p\u00E1gina por intera\u00E7\u00E3o do usu\u00E1rio ou pelo m\u00E9todo p\u00FAblico.\n\nEm `controlled`, o evento informa a p\u00E1gina solicitada, mas `current` s\u00F3\nmuda quando a aplica\u00E7\u00E3o confirma o resultado. O componente n\u00E3o faz\nchamadas remotas nem cancela a consulta do consumidor."
+                },
+                "complexType": {
+                    "original": "PaginationPageChangeDetail",
+                    "resolved": "{ page: number; }",
+                    "references": {
+                        "PaginationPageChangeDetail": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationPageChangeDetail",
+                            "referenceLocation": "PaginationPageChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brPaginationPageChange",
+                "name": "brPaginationPageChange",
+                "bubbles": true,
+                "cancelable": false,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento can\u00F4nico para iniciar o carregamento de uma p\u00E1gina.\nO `detail` cont\u00E9m `{ page }`; o evento n\u00E3o \u00E9 cancel\u00E1vel."
+                },
+                "complexType": {
+                    "original": "PaginationPageChangeDetail",
+                    "resolved": "{ page: number; }",
+                    "references": {
+                        "PaginationPageChangeDetail": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationPageChangeDetail",
+                            "referenceLocation": "PaginationPageChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "perPageChange",
+                "name": "perPageChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Solicita uma quantidade de itens por p\u00E1gina (variante contextual).\nEm `controlled`, a aplica\u00E7\u00E3o confirma a mudan\u00E7a atribuindo `perPage`."
+                },
+                "complexType": {
+                    "original": "PaginationPerPageChangeDetail",
+                    "resolved": "{ perPage: number; }",
+                    "references": {
+                        "PaginationPerPageChangeDetail": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationPerPageChangeDetail",
+                            "referenceLocation": "PaginationPerPageChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brPaginationPerPageChange",
+                "name": "brPaginationPerPageChange",
+                "bubbles": true,
+                "cancelable": false,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento can\u00F4nico para iniciar o carregamento de uma nova quantidade de\nitens. O `detail` cont\u00E9m `{ perPage }`; o evento n\u00E3o \u00E9 cancel\u00E1vel."
+                },
+                "complexType": {
+                    "original": "PaginationPerPageChangeDetail",
+                    "resolved": "{ perPage: number; }",
+                    "references": {
+                        "PaginationPerPageChangeDetail": {
+                            "location": "import",
+                            "path": "./pagination.types",
+                            "id": "src/components/pagination/pagination.types.ts::PaginationPerPageChangeDetail",
+                            "referenceLocation": "PaginationPerPageChangeDetail"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "setPage": {
+                "complexType": {
+                    "signature": "(page: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "page",
+                            "type": "number",
+                            "docs": "P\u00E1gina desejada (1-indexada).\nEm `controlled`, emite a solicita\u00E7\u00E3o sem alterar `current`."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Define programaticamente a p\u00E1gina atual dentro do intervalo permitido.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "page P\u00E1gina desejada (1-indexada).\nEm `controlled`, emite a solicita\u00E7\u00E3o sem alterar `current`."
+                        }]
+                }
+            },
+            "goToPage": {
+                "complexType": {
+                    "signature": "(page: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "page",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Solicita navega\u00E7\u00E3o program\u00E1tica para uma p\u00E1gina (1-indexada).\nEm `controlled`, aguarda a confirma\u00E7\u00E3o externa para alterar `current`.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "total",
+                "methodName": "handleTotalChange"
+            }, {
+                "propName": "totalPages",
+                "methodName": "handleTotalPagesChange"
+            }, {
+                "propName": "current",
+                "methodName": "handleCurrentChange"
+            }, {
+                "propName": "currentPage",
+                "methodName": "handleCurrentPageChange"
+            }, {
+                "propName": "perPage",
+                "methodName": "handlePerPagePropChange"
+            }, {
+                "propName": "totalItems",
+                "methodName": "handleTotalItemsChange"
+            }, {
+                "propName": "density",
+                "methodName": "handleDensityChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "valueChange",
+                "method": "handleContextualSelectChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}
+Pagination.ELLIPSIS_VISIBLE_ITEMS = 4;
+Pagination.ELLIPSIS_ITEM_HEIGHT_FALLBACK = 56;
+Pagination.ELLIPSIS_OVERSCAN = 1;
+Pagination.LARGE_PAGE_THRESHOLD = 10000;