@seniorsistemas/angular-components 19.5.4 → 19.5.5

package/esm2022/shared/lib/accessibility/datepicker-no-period-tab.directive.mjs

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

package/esm2022/shared/public-api.mjs

@@ -2,6 +2,7 @@ export { EnumSeverity } from './lib/shared/models/severities';
 export { BorderButtonComponent } from './lib/shared/border-button/border-button.component';
 export { BorderButtonModule } from './lib/shared/border-button/border-button.module';
 export * from './lib/shared/helpers';
+export { DatepickerNoPeriodTabDirective } from './lib/accessibility/datepicker-no-period-tab.directive';
 export { PaginatorAccessibilityDirective } from './lib/accessibility/paginator-accessibility.directive';
 export { TableCheckboxAccessibilityDirective } from './lib/accessibility/table-checkbox-accessibility.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9zaGFyZWQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9EQUFvRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQ3JGLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sdURBQXVELENBQUM7QUFDeEcsT0FBTyxFQUFFLG1DQUFtQyxFQUFFLE1BQU0sNERBQTRELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEJvcmRlckJ1dHRvbk9wdGlvbnMgfSBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL2JvcmRlci1idXR0b24tb3B0aW9ucyc7XG5leHBvcnQgdHlwZSB7IFNldmVyaXRpZXMgfSBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL3NldmVyaXRpZXMnO1xuZXhwb3J0IHsgRW51bVNldmVyaXR5IH0gZnJvbSAnLi9saWIvc2hhcmVkL21vZGVscy9zZXZlcml0aWVzJztcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbkNvbXBvbmVudCB9IGZyb20gJy4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24uY29tcG9uZW50JztcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbk1vZHVsZSB9IGZyb20gJy4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24ubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9oZWxwZXJzJztcbmV4cG9ydCB7IFBhZ2luYXRvckFjY2Vzc2liaWxpdHlEaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9hY2Nlc3NpYmlsaXR5L3BhZ2luYXRvci1hY2Nlc3NpYmlsaXR5LmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBUYWJsZUNoZWNrYm94QWNjZXNzaWJpbGl0eURpcmVjdGl2ZSB9IGZyb20gJy4vbGliL2FjY2Vzc2liaWxpdHkvdGFibGUtY2hlY2tib3gtYWNjZXNzaWJpbGl0eS5kaXJlY3RpdmUnO1xuXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9zaGFyZWQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9EQUFvRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQ3JGLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFDeEcsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sdURBQXVELENBQUM7QUFDeEcsT0FBTyxFQUFFLG1DQUFtQyxFQUFFLE1BQU0sNERBQTRELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEJvcmRlckJ1dHRvbk9wdGlvbnMgfSBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL2JvcmRlci1idXR0b24tb3B0aW9ucyc7XG5leHBvcnQgdHlwZSB7IFNldmVyaXRpZXMgfSBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL3NldmVyaXRpZXMnO1xuZXhwb3J0IHsgRW51bVNldmVyaXR5IH0gZnJvbSAnLi9saWIvc2hhcmVkL21vZGVscy9zZXZlcml0aWVzJztcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbkNvbXBvbmVudCB9IGZyb20gJy4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24uY29tcG9uZW50JztcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbk1vZHVsZSB9IGZyb20gJy4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24ubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9oZWxwZXJzJztcbmV4cG9ydCB7IERhdGVwaWNrZXJOb1BlcmlvZFRhYkRpcmVjdGl2ZSB9IGZyb20gJy4vbGliL2FjY2Vzc2liaWxpdHkvZGF0ZXBpY2tlci1uby1wZXJpb2QtdGFiLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBQYWdpbmF0b3JBY2Nlc3NpYmlsaXR5RGlyZWN0aXZlIH0gZnJvbSAnLi9saWIvYWNjZXNzaWJpbGl0eS9wYWdpbmF0b3ItYWNjZXNzaWJpbGl0eS5kaXJlY3RpdmUnO1xuZXhwb3J0IHsgVGFibGVDaGVja2JveEFjY2Vzc2liaWxpdHlEaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9hY2Nlc3NpYmlsaXR5L3RhYmxlLWNoZWNrYm94LWFjY2Vzc2liaWxpdHkuZGlyZWN0aXZlJztcblxuIl19