@seniorsistemas/angular-components 19.5.4 → 19.5.5

package/fesm2022/seniorsistemas-angular-components-shared.mjs

@@ -1,9 +1,10 @@
 import * as i0 from '@angular/core';
-import { Component, Input, NgModule, inject, ElementRef, Renderer2, Directive } from '@angular/core';
+import { Component, Input, NgModule, inject, Renderer2, LOCALE_ID, Directive, HostListener, ElementRef } from '@angular/core';
 import * as i1 from '@angular/common';
-import { CommonModule } from '@angular/common';
+import { CommonModule, DOCUMENT } from '@angular/common';
 import * as i2 from '@seniorsistemas/angular-components/tooltip';
 import { TooltipModule } from '@seniorsistemas/angular-components/tooltip';
+import { DatePicker } from 'primeng/datepicker';
 import { TranslateService } from '@ngx-translate/core';
 
 var EnumSeverity;
@@ -83,6 +84,543 @@ function CheckDisabled(disabledField = 'disabled') {
     };
 }
 
+/**
+ * CSS customizado injetado globalmente para focus-visible nos internals do DatePicker.
+ * Necessário porque com `appendTo="body"` o overlay fica fora do host component,
+ * e estilos com `:host ::ng-deep` ou ViewEncapsulation.Emulated não alcançam.
+ */
+const FOCUS_STYLE_ID = 's-datepicker-a11y-focus-styles';
+/** Delay em ms para foco pós-abertura e navegação (permite NVDA processar dialog announce). */
+const FOCUS_DELAY_MS = 50;
+/** Delay em ms para debounce do MutationObserver (evita re-execução por ripple/animações). */
+const MUTATION_DEBOUNCE_MS = 100;
+/** Attribute name constant to avoid SonarQube literal duplication warning. */
+const ARIA_LABEL_ATTR = 'aria-label';
+const FOCUS_STYLES = `
+.p-datepicker-day:focus-visible,
+.p-datepicker-day.s-datepicker-day-focused {
+    outline: 2px solid var(--p-primary-color, #3b82f6) !important;
+    outline-offset: -2px;
+    border-radius: 4px;
+}
+.p-datepicker-month:focus-visible,
+.p-datepicker-month.s-datepicker-day-focused {
+    outline: 2px solid var(--p-primary-color, #3b82f6) !important;
+    outline-offset: -2px;
+    border-radius: 4px;
+}
+.p-datepicker-year:focus-visible,
+.p-datepicker-year.s-datepicker-day-focused {
+    outline: 2px solid var(--p-primary-color, #3b82f6) !important;
+    outline-offset: -2px;
+    border-radius: 4px;
+}
+.p-datepicker-select-month:focus-visible,
+.p-datepicker-select-year:focus-visible {
+    outline: 2px solid var(--p-primary-color, #3b82f6) !important;
+    outline-offset: 2px;
+    border-radius: 4px;
+}
+.p-datepicker-prev-button:focus-visible,
+.p-datepicker-next-button:focus-visible {
+    outline: 2px solid var(--p-primary-color, #3b82f6) !important;
+    outline-offset: 2px;
+    border-radius: 50%;
+}
+`;
+/**
+ * Traduções pt-BR para aria-labels do DatePicker PrimeNG.
+ * PrimeNG usa `getTranslation()` que retorna inglês por padrão
+ * se não configurado via `PrimeNGConfig.setTranslation()`.
+ *
+ * Keys correspondem ao texto exato renderizado pelo PrimeNG no DOM:
+ * - "Previous Month" (não "Prev Month")
+ * - "Choose Date", "Choose Month", "Choose Year"
+ */
+const PREV_DECADE_PT = 'Década anterior';
+const PREV_DECADE_ES = 'Década anterior';
+const ARIA_TRANSLATIONS_PT_BR = {
+    'Choose Date': 'Selecionar data',
+    'Choose Month': 'Selecionar mês',
+    'Choose Year': 'Selecionar ano',
+    'Previous Month': 'Mês anterior',
+    'Next Month': 'Próximo mês',
+    'Previous Year': 'Ano anterior',
+    'Next Year': 'Próximo ano',
+    'Previous Decade': PREV_DECADE_PT,
+    'Next Decade': 'Próxima década',
+    'Prev Month': 'Mês anterior',
+    'Prev Year': 'Ano anterior',
+    'Prev Decade': PREV_DECADE_PT,
+};
+const ARIA_TRANSLATIONS_ES = {
+    'Choose Date': 'Seleccionar fecha',
+    'Choose Month': 'Seleccionar mes',
+    'Choose Year': 'Seleccionar año',
+    'Previous Month': 'Mes anterior',
+    'Next Month': 'Próximo mes',
+    'Previous Year': 'Año anterior',
+    'Next Year': 'Próximo año',
+    'Previous Decade': PREV_DECADE_ES,
+    'Next Decade': 'Próxima década',
+    'Prev Month': 'Mes anterior',
+    'Prev Year': 'Año anterior',
+    'Prev Decade': PREV_DECADE_ES,
+};
+const ARIA_TRANSLATIONS = {
+    'pt-BR': ARIA_TRANSLATIONS_PT_BR,
+    'pt': ARIA_TRANSLATIONS_PT_BR,
+    'es': ARIA_TRANSLATIONS_ES,
+    'es-CO': ARIA_TRANSLATIONS_ES,
+    'es-ES': ARIA_TRANSLATIONS_ES,
+};
+/**
+ * Diretiva para corrigir a acessibilidade do painel do DatePicker PrimeNG.
+ *
+ * Resolve os seguintes problemas:
+ *
+ * 1. **Foco inicial ao abrir overlay**: move foco programaticamente para
+ *    a célula selecionada, hoje, ou primeira célula disponível — evitando
+ *    que NVDA leia toda estrutura do grid ao entrar no painel.
+ *
+ * 2. **Re-foco ao trocar view (mês/ano)**: ao navegar para views de mês ou
+ *    ano, o DOM é destruído e recriado. Sem intervenção, foco escapa para
+ *    `<body>` e NVDA lê conteúdo fora do overlay. A diretiva re-foca o
+ *    primeiro elemento interativo da nova view.
+ *
+ * 3. **Focus-visible nos elementos internos**: injeta CSS global com
+ *    outline para todos elementos interativos do overlay, garantindo
+ *    feedback visual mesmo com `appendTo="body"`.
+ *
+ * 4. **aria-label enriquecido nos day cells**: PrimeNG seta apenas o
+ *    número do dia. A diretiva sobrescreve com data completa formatada
+ *    (ex: "3 de junho de 2026, Qua") — NVDA narra label sem precisar
+ *    contextualizar toda grid.
+ *
+ * 5. **View de meses/anos sem tabindex**: spans de mês/ano recebem
+ *    `tabindex="0"` e `role="option"` para navegação por teclado.
+ *
+ * Utiliza `MutationObserver` para detectar mudanças internas de view,
+ * já que PrimeNG não emite eventos para essas transições.
+ *
+ * **CSS**: A diretiva injeta um `<style>` global no `<head>` (uma vez).
+ * Para projetos que preferem controle manual, desabilite via Input
+ * `[sDatepickerInjectStyles]="false"` e importe os estilos manualmente.
+ *
+ * Uso: `<p-datepicker sDatepickerNoPeriodTab ...>`
+ *
+ * @category Directives
+ */
+class DatepickerNoPeriodTabDirective {
+    datePicker = inject(DatePicker);
+    renderer = inject(Renderer2);
+    locale = inject(LOCALE_ID);
+    document = inject(DOCUMENT);
+    observer = null;
+    focusListenerCleanups = [];
+    constructor() {
+        this.injectGlobalFocusStyles();
+    }
+    onPanelShow() {
+        setTimeout(() => {
+            this.fixPanelAccessibility();
+            // Não chamar focusBestTarget() aqui — PrimeNG initFocusableCell()
+            // já move foco pro day cell com tabindex="0" na abertura.
+            // Chamar de novo causa double-announce no NVDA.
+            setTimeout(() => this.observePanelChanges(), MUTATION_DEBOUNCE_MS);
+        }, FOCUS_DELAY_MS);
+    }
+    onNavigationChange() {
+        setTimeout(() => {
+            this.fixPanelAccessibility();
+            this.focusBestTarget();
+        }, FOCUS_DELAY_MS);
+    }
+    ngOnDestroy() {
+        this.disconnectObserver();
+        this.removeFocusListeners();
+    }
+    /**
+     * Move foco para melhor alvo disponível no painel.
+     * Usado ao abrir overlay e ao trocar view (mês/ano).
+     *
+     * Ao abrir: evita que NVDA leia toda estrutura do grid.
+     * Ao trocar view: previne foco escapar para `<body>` quando
+     * PrimeNG destrói DOM da view anterior.
+     *
+     * Prioridade: selecionado > hoje > primeiro disponível.
+     * Pula se foco já está no target correto (evita double-announce no NVDA).
+     */
+    focusBestTarget() {
+        const panel = this.datePicker.overlay;
+        if (!panel) {
+            return;
+        }
+        const target = this.findFocusTarget(panel);
+        if (target && this.document.activeElement !== target) {
+            target.tabIndex = 0;
+            target.focus();
+        }
+    }
+    /**
+     * Injeta CSS global de focus-visible no `<head>` do documento.
+     * Executa apenas uma vez (idempotente via ID do style element).
+     * Necessário porque overlay com `appendTo="body"` fica fora do
+     * escopo de ViewEncapsulation do componente host.
+     */
+    injectGlobalFocusStyles() {
+        if (this.document.getElementById(FOCUS_STYLE_ID)) {
+            return;
+        }
+        const style = this.renderer.createElement('style');
+        this.renderer.setAttribute(style, 'id', FOCUS_STYLE_ID);
+        this.renderer.setAttribute(style, 'type', 'text/css');
+        const text = this.renderer.createText(FOCUS_STYLES);
+        this.renderer.appendChild(style, text);
+        this.renderer.appendChild(this.document.head, style);
+    }
+    /**
+     * Encontra melhor elemento para receber foco no painel atual.
+     * Busca em ordem: selecionado → hoje → primeiro disponível.
+     * Funciona para views de dias, meses e anos.
+     */
+    findFocusTarget(panel) {
+        // View de dias
+        const selectedDay = panel.querySelector('.p-datepicker-day-selected, .p-datepicker-day[aria-selected="true"]');
+        if (selectedDay) {
+            return selectedDay;
+        }
+        const today = panel.querySelector('.p-datepicker-today .p-datepicker-day');
+        if (today) {
+            return today;
+        }
+        // View de meses
+        const selectedMonth = panel.querySelector('.p-datepicker-month.p-datepicker-month-selected');
+        if (selectedMonth) {
+            return selectedMonth;
+        }
+        const firstMonth = panel.querySelector('.p-datepicker-month:not(.p-disabled)');
+        if (firstMonth) {
+            return firstMonth;
+        }
+        // View de anos
+        const selectedYear = panel.querySelector('.p-datepicker-year.p-datepicker-year-selected');
+        if (selectedYear) {
+            return selectedYear;
+        }
+        const firstYear = panel.querySelector('.p-datepicker-year:not(.p-disabled)');
+        if (firstYear) {
+            return firstYear;
+        }
+        // Fallback: primeiro day cell disponível
+        const firstDay = panel.querySelector('.p-datepicker-day:not(.p-disabled)');
+        return firstDay;
+    }
+    /**
+     * Aplica correções de acessibilidade no painel do DatePicker,
+     * independente da view interna ativa (dias, meses ou anos).
+     */
+    fixPanelAccessibility() {
+        const panel = this.datePicker.overlay;
+        if (!panel) {
+            return;
+        }
+        panel.querySelectorAll('.p-datepicker-select-month, .p-datepicker-select-year').forEach((btn) => {
+            this.renderer.setAttribute(btn, 'tabindex', '0');
+        });
+        panel.querySelectorAll('.p-datepicker-month:not([tabindex])').forEach((month) => {
+            this.renderer.setAttribute(month, 'tabindex', '0');
+            this.renderer.setAttribute(month, 'role', 'option');
+        });
+        panel.querySelectorAll('.p-datepicker-year:not([tabindex])').forEach((year) => {
+            this.renderer.setAttribute(year, 'tabindex', '0');
+            this.renderer.setAttribute(year, 'role', 'option');
+        });
+        this.applyGridcellRoleToDays(panel);
+        this.enrichDayCellAriaLabels(panel);
+        this.enrichGridAriaLabel(panel);
+        this.translateAriaLabels(panel);
+        this.fixNavigationButtonLabels(panel);
+        this.removeApplicationRoleFromContainer(panel);
+        this.setupFocusTracking(panel);
+    }
+    /**
+     * Adiciona `role="gridcell"` nos `<span class="p-datepicker-day">` que recebem foco.
+     *
+     * PrimeNG coloca `tabindex` no `<span>` dentro do `<td>`, mas sem role explícito.
+     * NVDA não entra automaticamente em focus mode quando foca um elemento sem
+     * role de widget (gridcell, button, etc). Resultado: NVDA fica em browse mode
+     * e lê toda a tabela sequencialmente ao invés de anunciar só a célula focada.
+     *
+     * Ao adicionar `role="gridcell"` no span focável, NVDA reconhece que é um
+     * widget interativo e entra em focus mode — anunciando apenas o aria-label
+     * da célula focada.
+     */
+    applyGridcellRoleToDays(panel) {
+        panel.querySelectorAll('.p-datepicker-day:not(.p-disabled)').forEach((daySpan) => {
+            if (!daySpan.getAttribute('role')) {
+                this.renderer.setAttribute(daySpan, 'role', 'gridcell');
+            }
+        });
+    }
+    /**
+     * Enriquece `aria-label` dos day cells com data completa formatada.
+     * PrimeNG por padrão usa apenas o número do dia, forçando NVDA
+     * a narrar contexto de grid (linha/coluna/weekday) para informar a data.
+     * Com aria-label completo, NVDA narra diretamente a data sem verbosidade.
+     */
+    enrichDayCellAriaLabels(panel) {
+        const { currentMonth, currentYear } = this.datePicker;
+        if (currentMonth == null || currentYear == null) {
+            return;
+        }
+        const weekdayHeaders = panel.querySelectorAll('.p-datepicker-weekday');
+        const weekdays = [];
+        weekdayHeaders.forEach((header) => {
+            weekdays.push(header.textContent?.trim() || '');
+        });
+        const rows = panel.querySelectorAll('.p-datepicker-day-view tbody tr');
+        rows.forEach((row) => {
+            const cells = row.querySelectorAll('td');
+            cells.forEach((cell, cellIndex) => {
+                const daySpan = cell.querySelector('.p-datepicker-day');
+                if (!daySpan) {
+                    return;
+                }
+                const dayNumber = parseInt(daySpan.textContent?.trim() || '0', 10);
+                if (!dayNumber) {
+                    return;
+                }
+                const isOtherMonth = cell.classList.contains('p-datepicker-other-month');
+                if (isOtherMonth) {
+                    return;
+                }
+                const date = new Date(currentYear, currentMonth, dayNumber);
+                const formattedDate = this.formatDateForAriaLabel(date);
+                const weekday = weekdays[cellIndex] || '';
+                const ariaLabel = weekday ? `${formattedDate}, ${weekday}` : formattedDate;
+                this.renderer.setAttribute(daySpan, ARIA_LABEL_ATTR, ariaLabel);
+            });
+        });
+    }
+    /**
+     * Adiciona aria-label no grid com mês/ano atual para dar contexto
+     * imediato ao NVDA ao entrar na tabela de dias.
+     * Exemplo: "Calendário, Junho 2026"
+     */
+    enrichGridAriaLabel(panel) {
+        const grid = panel.querySelector('.p-datepicker-day-view[role="grid"]');
+        if (!grid) {
+            return;
+        }
+        const { currentMonth, currentYear } = this.datePicker;
+        if (currentMonth == null || currentYear == null) {
+            return;
+        }
+        const monthName = new Date(currentYear, currentMonth, 1).toLocaleDateString('pt-BR', {
+            month: 'long',
+        });
+        const capitalizedMonth = monthName.charAt(0).toUpperCase() + monthName.slice(1);
+        const label = `Calendário, ${capitalizedMonth} ${currentYear}`;
+        this.renderer.setAttribute(grid, ARIA_LABEL_ATTR, label);
+    }
+    /**
+     * Formata data para aria-label legível por leitor de tela.
+     * Sempre usa pt-BR para garantir consistência com labels traduzidos,
+     * independente do LOCALE_ID configurado no Angular.
+     * Exemplo: "3 de junho de 2026"
+     */
+    formatDateForAriaLabel(date) {
+        try {
+            return date.toLocaleDateString('pt-BR', {
+                day: 'numeric',
+                month: 'long',
+                year: 'numeric',
+            });
+        }
+        catch {
+            return `${date.getDate()}/${date.getMonth() + 1}/${date.getFullYear()}`;
+        }
+    }
+    /**
+     * Retorna locale string para formatação.
+     */
+    getLocale() {
+        return this.locale || 'pt-BR';
+    }
+    /**
+     * Traduz aria-labels dos botões do header que PrimeNG renderiza em inglês.
+     * PrimeNG usa `getTranslation('chooseDate')` etc, que retorna inglês
+     * se `PrimeNGConfig.setTranslation()` não foi configurado pelo projeto.
+     *
+     * Busca botões com aria-label em inglês e traduz pro locale atual.
+     */
+    translateAriaLabels(panel) {
+        const translations = this.getTranslations();
+        // Dialog aria-label ("Choose Date")
+        const dialog = panel.closest('[role="dialog"]') || panel;
+        const dialogLabel = dialog.getAttribute(ARIA_LABEL_ATTR);
+        if (dialogLabel && translations[dialogLabel]) {
+            this.renderer.setAttribute(dialog, ARIA_LABEL_ATTR, translations[dialogLabel]);
+        }
+        // Botões "Choose Month" e "Choose Year" no header
+        panel.querySelectorAll('.p-datepicker-select-month, .p-datepicker-select-year').forEach((btn) => {
+            const label = btn.getAttribute(ARIA_LABEL_ATTR);
+            if (label && translations[label]) {
+                this.renderer.setAttribute(btn, ARIA_LABEL_ATTR, translations[label]);
+            }
+        });
+    }
+    /**
+     * Corrige aria-label dos botões prev/next do PrimeNG.
+     * PrimeNG usa `p-button` component que seta `aria-label` no host element `<p-button>`,
+     * mas NVDA foca o `<button>` interno que não herda o label do custom element.
+     *
+     * Estrutura DOM: `<p-button aria-label="Previous Month"><button class="p-datepicker-prev-button">...</button></p-button>`
+     *
+     * Fix: lê aria-label do `<p-button>` host, traduz, e propaga pro `<button>` interno.
+     */
+    fixNavigationButtonLabels(panel) {
+        const translations = this.getTranslations();
+        // Buscar <p-button> hosts que contém os botões prev/next
+        const pButtons = panel.querySelectorAll('p-button');
+        pButtons.forEach((pBtn) => {
+            const innerButton = pBtn.querySelector('button.p-datepicker-prev-button, button.p-datepicker-next-button');
+            if (!innerButton) {
+                return;
+            }
+            let label = pBtn.getAttribute(ARIA_LABEL_ATTR) || '';
+            // Traduzir
+            if (label && translations[label]) {
+                label = translations[label];
+                this.renderer.setAttribute(pBtn, ARIA_LABEL_ATTR, label);
+            }
+            // Propagar pro <button> interno
+            if (label) {
+                this.renderer.setAttribute(innerButton, ARIA_LABEL_ATTR, label);
+            }
+        });
+    }
+    /**
+     * Remove `role="application"` do container do calendário.
+     *
+     * PrimeNG seta `role="application"` no `.p-datepicker-calendar-container`
+     * para que arrow keys cheguem no JavaScript sem interceptação do browse mode.
+     * Porém `role="grid"` na table já garante esse comportamento — NVDA entra
+     * automaticamente em focus mode ao focar uma gridcell.
+     *
+     * O `role="application"` no container PAI causa NVDA a despeja o conteúdo
+     * virtual do container inteiro ao entrar no dialog, antes de pousar na célula.
+     * Removê-lo resolve a leitura excessiva sem quebrar navegação por setas.
+     */
+    removeApplicationRoleFromContainer(panel) {
+        const calendarContainer = panel.querySelector('.p-datepicker-calendar-container');
+        if (calendarContainer?.getAttribute('role') === 'application') {
+            this.renderer.removeAttribute(calendarContainer, 'role');
+        }
+    }
+    /**
+     * Retorna mapa de traduções pro locale atual.
+     * Se locale é inglês ou não reconhecido, fallback pra pt-BR
+     * (assumimos que labels em inglês devem ser traduzidos).
+     */
+    getTranslations() {
+        const locale = this.getLocale();
+        return ARIA_TRANSLATIONS[locale]
+            || ARIA_TRANSLATIONS[locale.split('-')[0]]
+            || ARIA_TRANSLATIONS_PT_BR;
+    }
+    /**
+     * Adiciona listeners de focus/blur nos elementos interativos para
+     * garantir indicador visual quando `.focus()` é chamado programaticamente.
+     *
+     * `:focus-visible` pode não ser aplicado quando foco é movido via JS,
+     * então usamos classe auxiliar `s-datepicker-day-focused` como fallback.
+     */
+    setupFocusTracking(panel) {
+        this.removeFocusListeners();
+        const focusableElements = panel.querySelectorAll('.p-datepicker-day, .p-datepicker-month, .p-datepicker-year');
+        focusableElements.forEach((el) => {
+            const focusCleanup = this.renderer.listen(el, 'focus', () => {
+                this.renderer.addClass(el, 's-datepicker-day-focused');
+            });
+            const blurCleanup = this.renderer.listen(el, 'blur', () => {
+                this.renderer.removeClass(el, 's-datepicker-day-focused');
+            });
+            this.focusListenerCleanups.push(focusCleanup, blurCleanup);
+        });
+    }
+    /**
+     * Remove listeners de focus/blur registrados anteriormente.
+     */
+    removeFocusListeners() {
+        this.focusListenerCleanups.forEach((cleanup) => cleanup());
+        this.focusListenerCleanups = [];
+    }
+    /**
+     * Observa mudanças no DOM do painel para reaplicar correções
+     * quando o PrimeNG troca a view interna (dias → meses → anos).
+     * Usa debounce e só reage a childList changes (não attributes)
+     * para evitar loop infinito com as próprias mutações da diretiva.
+     */
+    observePanelChanges() {
+        this.disconnectObserver();
+        const panel = this.datePicker.overlay;
+        if (!panel) {
+            return;
+        }
+        let debounceTimer = null;
+        let isProcessing = false;
+        this.observer = new MutationObserver((mutations) => {
+            if (isProcessing) {
+                return;
+            }
+            // Só reagir se houve adição/remoção de nós (troca de view)
+            const hasStructuralChange = mutations.some((m) => m.type === 'childList' && (m.addedNodes.length > 0 || m.removedNodes.length > 0));
+            if (!hasStructuralChange) {
+                return;
+            }
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(() => {
+                isProcessing = true;
+                this.fixPanelAccessibility();
+                this.focusBestTarget();
+                isProcessing = false;
+            }, MUTATION_DEBOUNCE_MS);
+        });
+        this.observer.observe(panel, {
+            childList: true,
+            subtree: true,
+        });
+    }
+    disconnectObserver() {
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatepickerNoPeriodTabDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DatepickerNoPeriodTabDirective, isStandalone: true, selector: "[sDatepickerNoPeriodTab]", host: { listeners: { "onShow": "onPanelShow()", "onMonthChange": "onNavigationChange()", "onYearChange": "onNavigationChange()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatepickerNoPeriodTabDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sDatepickerNoPeriodTab]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { onPanelShow: [{
+                type: HostListener,
+                args: ['onShow']
+            }], onNavigationChange: [{
+                type: HostListener,
+                args: ['onMonthChange']
+            }, {
+                type: HostListener,
+                args: ['onYearChange']
+            }] } });
+
 /**
  * Diretiva para melhorar a acessibilidade dos botões do paginador PrimeNG
  * Adiciona tabindex="0" aos botões habilitados e tabindex="-1" aos desabilitados
@@ -430,5 +968,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { BorderButtonComponent, BorderButtonModule, CheckDisabled, EnumSeverity, PaginatorAccessibilityDirective, TableCheckboxAccessibilityDirective };
+export { BorderButtonComponent, BorderButtonModule, CheckDisabled, DatepickerNoPeriodTabDirective, EnumSeverity, PaginatorAccessibilityDirective, TableCheckboxAccessibilityDirective };
 //# sourceMappingURL=seniorsistemas-angular-components-shared.mjs.map