@seniorsistemas/angular-components 19.0.9 → 19.1.1

package/esm2022/shared/lib/accessibility/paginator-accessibility.directive.mjs

@@ -0,0 +1,182 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+/**
+ * Diretiva para melhorar a acessibilidade dos botões do paginador PrimeNG
+ * Adiciona tabindex="0" aos botões habilitados e tabindex="-1" aos desabilitados
+ * Adiciona aria-labels traduzidos para os botões do paginador
+ */
+export class PaginatorAccessibilityDirective {
+    el;
+    renderer;
+    translateService;
+    observer = null;
+    equalWebSpanMarker = 'data-equalweb-sr-only';
+    isObserverPaused = false;
+    observedPaginatorElement = null;
+    constructor(el, renderer, translateService) {
+        this.el = el;
+        this.renderer = renderer;
+        this.translateService = translateService;
+    }
+    ngOnInit() {
+        // Aguarda o próximo ciclo para garantir que o paginador foi renderizado
+        setTimeout(() => {
+            this.updatePaginatorButtons();
+            this.observePaginatorChanges();
+        });
+    }
+    ngOnDestroy() {
+        if (this.observer) {
+            this.observer.disconnect();
+        }
+    }
+    updatePaginatorButtons() {
+        const paginatorElement = this.el.nativeElement.querySelector('p-paginator');
+        if (!paginatorElement) {
+            return;
+        }
+        // Atualiza botões de navegação (first, prev, next, last)
+        const navigationSelectors = {
+            '.p-paginator-first': this.translateService.instant('platform.angular_components.aria_first_page'),
+            '.p-paginator-prev': this.translateService.instant('platform.angular_components.aria_previous_page'),
+            '.p-paginator-next': this.translateService.instant('platform.angular_components.aria_next_page'),
+            '.p-paginator-last': this.translateService.instant('platform.angular_components.aria_last_page'),
+            '.p-select-label': this.translateService.instant('platform.angular_components.aria_page_selection')
+        };
+        Object.entries(navigationSelectors).forEach(([selector, label]) => {
+            const button = paginatorElement.querySelector(selector);
+            if (button) {
+                const isDisabled = this.isButtonDisabled(button);
+                this.updateTabIndex(button, isDisabled);
+                if (isDisabled) {
+                    this.renderer.removeAttribute(button, 'data-ind-readable');
+                }
+                else {
+                    this.renderer.setAttribute(button, 'data-ind-readable', 'true');
+                }
+                this.renderer.setAttribute(button, 'aria-label', label);
+                this.applyEqualWebTextFix(button, label, isDisabled);
+            }
+        });
+        // Atualiza botões de página numérica
+        const pageButtons = paginatorElement.querySelectorAll('.p-paginator-page');
+        pageButtons.forEach((button) => {
+            const pageNumber = this.getPaginatorPageNumber(button);
+            if (pageNumber) {
+                const isDisabled = this.isButtonDisabled(button);
+                const isSelected = button.classList.contains('p-paginator-page-selected');
+                const ariaLabel = isSelected
+                    ? this.translateService.instant('platform.angular_components.aria_current_page', { page: pageNumber })
+                    : this.translateService.instant('platform.angular_components.aria_page_number', { page: pageNumber });
+                this.renderer.setAttribute(button, 'aria-label', ariaLabel);
+                this.updateTabIndex(button, isDisabled);
+                this.applyEqualWebTextFix(button, ariaLabel, isDisabled);
+                if (isSelected) {
+                    this.renderer.setAttribute(button, 'aria-current', 'page');
+                }
+                else {
+                    this.renderer.removeAttribute(button, 'aria-current');
+                }
+            }
+        });
+    }
+    isButtonDisabled(button) {
+        return button.hasAttribute('disabled') || button.classList.contains('p-disabled');
+    }
+    updateTabIndex(button, isDisabled) {
+        if (isDisabled) {
+            this.renderer.removeAttribute(button, 'tabindex');
+            return;
+        }
+        this.renderer.setAttribute(button, 'tabindex', '0');
+    }
+    getPaginatorPageNumber(button) {
+        const buttonElement = button;
+        // Evita pegar texto do span sr-only criado pela diretiva.
+        const visualLabel = buttonElement.querySelector(`span:not([${this.equalWebSpanMarker}])`);
+        const visualText = visualLabel?.textContent?.trim();
+        if (visualText) {
+            return visualText;
+        }
+        // Fallback para casos em que o PrimeNG renderiza sem span interno.
+        const srOnlyText = buttonElement.querySelector(`span[${this.equalWebSpanMarker}="true"]`)?.textContent?.trim() || '';
+        const fullText = buttonElement.textContent?.trim() || '';
+        return fullText.replace(srOnlyText, '').trim();
+    }
+    applyEqualWebTextFix(button, accessibleText, isDisabled) {
+        const buttonElement = button;
+        // Oculta spans visuais do PrimeNG para o script do EqualWeb.
+        const visualSpans = buttonElement.querySelectorAll(`span:not([${this.equalWebSpanMarker}])`);
+        visualSpans.forEach((span) => {
+            this.renderer.setAttribute(span, 'aria-hidden', 'true');
+        });
+        const existingSrOnly = buttonElement.querySelector(`span[${this.equalWebSpanMarker}="true"]`);
+        // Não mantém texto extra em botões desabilitados.
+        if (isDisabled) {
+            if (existingSrOnly) {
+                this.renderer.removeChild(buttonElement, existingSrOnly);
+            }
+            return;
+        }
+        if (existingSrOnly) {
+            this.renderer.removeAttribute(existingSrOnly, 'tabindex');
+            this.renderer.setProperty(existingSrOnly, 'textContent', accessibleText);
+            return;
+        }
+        const srOnlySpan = this.renderer.createElement('span');
+        this.renderer.addClass(srOnlySpan, 'sr-only');
+        this.renderer.setAttribute(srOnlySpan, this.equalWebSpanMarker, 'true');
+        this.renderer.removeAttribute(srOnlySpan, 'tabindex');
+        const srOnlyText = this.renderer.createText(accessibleText);
+        this.renderer.appendChild(srOnlySpan, srOnlyText);
+        this.renderer.appendChild(buttonElement, srOnlySpan);
+    }
+    observePaginatorChanges() {
+        const paginatorElement = this.el.nativeElement.querySelector('p-paginator');
+        if (!paginatorElement) {
+            return;
+        }
+        this.observedPaginatorElement = paginatorElement;
+        // Observa mudanças no paginador (quando botões são habilitados/desabilitados)
+        this.observer = new MutationObserver(() => {
+            this.updateWithObserverPaused();
+        });
+        this.startObserving();
+    }
+    updateWithObserverPaused() {
+        if (!this.observer || this.isObserverPaused) {
+            return;
+        }
+        this.isObserverPaused = true;
+        this.observer.disconnect();
+        try {
+            this.updatePaginatorButtons();
+        }
+        finally {
+            this.startObserving();
+            this.isObserverPaused = false;
+        }
+    }
+    startObserving() {
+        if (!this.observer || !this.observedPaginatorElement) {
+            return;
+        }
+        this.observer.observe(this.observedPaginatorElement, {
+            attributes: true,
+            childList: true,
+            subtree: true,
+            attributeFilter: ['disabled', 'class', 'tabindex']
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginatorAccessibilityDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: PaginatorAccessibilityDirective, isStandalone: true, selector: "[sPaginatorAccessibility]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginatorAccessibilityDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sPaginatorAccessibility]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paginator-accessibility.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/shared/src/lib/accessibility/paginator-accessibility.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, OnInit, Renderer2, OnDestroy } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\n\n/**\n * Diretiva para melhorar a acessibilidade dos botões do paginador PrimeNG\n * Adiciona tabindex=\"0\" aos botões habilitados e tabindex=\"-1\" aos desabilitados\n * Adiciona aria-labels traduzidos para os botões do paginador\n */\n@Directive({\n  selector: '[sPaginatorAccessibility]',\n  standalone: true\n})\nexport class PaginatorAccessibilityDirective implements OnInit, OnDestroy {\n  private observer: MutationObserver | null = null;\n  private readonly equalWebSpanMarker = 'data-equalweb-sr-only';\n  private isObserverPaused = false;\n  private observedPaginatorElement: Element | null = null;\n\n  constructor(\n    private readonly el: ElementRef,\n    private readonly renderer: Renderer2,\n    private readonly translateService: TranslateService\n  ) {}\n\n  ngOnInit() {\n    // Aguarda o próximo ciclo para garantir que o paginador foi renderizado\n    setTimeout(() => {\n      this.updatePaginatorButtons();\n      this.observePaginatorChanges();\n    });\n  }\n\n  ngOnDestroy() {\n    if (this.observer) {\n      this.observer.disconnect();\n      }\n    }\n\n  private updatePaginatorButtons() {\n    const paginatorElement = this.el.nativeElement.querySelector('p-paginator');\n    if (!paginatorElement) {\n      return;\n    }\n\n    // Atualiza botões de navegação (first, prev, next, last)\n    const navigationSelectors = {\n      '.p-paginator-first': this.translateService.instant('platform.angular_components.aria_first_page'),\n      '.p-paginator-prev': this.translateService.instant('platform.angular_components.aria_previous_page'),\n      '.p-paginator-next': this.translateService.instant('platform.angular_components.aria_next_page'),\n      '.p-paginator-last': this.translateService.instant('platform.angular_components.aria_last_page'),\n      '.p-select-label': this.translateService.instant('platform.angular_components.aria_page_selection')\n    };\n\n    Object.entries(navigationSelectors).forEach(([selector, label]) => {\n      const button = paginatorElement.querySelector(selector);\n      if (button) {\n        const isDisabled = this.isButtonDisabled(button);\n        this.updateTabIndex(button, isDisabled);\n        if (isDisabled) {\n          this.renderer.removeAttribute(button, 'data-ind-readable');\n        } else {\n          this.renderer.setAttribute(button, 'data-ind-readable', 'true');\n        }\n        this.renderer.setAttribute(button, 'aria-label', label);\n        this.applyEqualWebTextFix(button, label, isDisabled);\n      }\n    });\n\n    // Atualiza botões de página numérica\n    const pageButtons = paginatorElement.querySelectorAll('.p-paginator-page');\n    pageButtons.forEach((button: Element) => {\n      const pageNumber = this.getPaginatorPageNumber(button);\n      if (pageNumber) {\n        const isDisabled = this.isButtonDisabled(button);\n        const isSelected = button.classList.contains('p-paginator-page-selected');\n        const ariaLabel = isSelected \n          ? this.translateService.instant('platform.angular_components.aria_current_page', { page: pageNumber })\n          : this.translateService.instant('platform.angular_components.aria_page_number', { page: pageNumber });\n        this.renderer.setAttribute(button, 'aria-label', ariaLabel);\n        this.updateTabIndex(button, isDisabled);\n        this.applyEqualWebTextFix(button, ariaLabel, isDisabled);\n        \n        if (isSelected) {\n          this.renderer.setAttribute(button, 'aria-current', 'page');\n        } else {\n          this.renderer.removeAttribute(button, 'aria-current');\n        }\n      }\n    });\n  }\n\n  private isButtonDisabled(button: Element): boolean {\n    return button.hasAttribute('disabled') || button.classList.contains('p-disabled');\n  }\n\n  private updateTabIndex(button: Element, isDisabled: boolean) {\n    if (isDisabled) {\n      this.renderer.removeAttribute(button, 'tabindex');\n      return;\n    }\n\n    this.renderer.setAttribute(button, 'tabindex', '0');\n  }\n\n  private getPaginatorPageNumber(button: Element): string {\n    const buttonElement = button as HTMLElement;\n\n    // Evita pegar texto do span sr-only criado pela diretiva.\n    const visualLabel = buttonElement.querySelector(`span:not([${this.equalWebSpanMarker}])`);\n    const visualText = visualLabel?.textContent?.trim();\n    if (visualText) {\n      return visualText;\n    }\n\n    // Fallback para casos em que o PrimeNG renderiza sem span interno.\n    const srOnlyText = buttonElement.querySelector(`span[${this.equalWebSpanMarker}=\"true\"]`)?.textContent?.trim() || '';\n    const fullText = buttonElement.textContent?.trim() || '';\n    return fullText.replace(srOnlyText, '').trim();\n  }\n\n  private applyEqualWebTextFix(button: Element, accessibleText: string, isDisabled: boolean) {\n    const buttonElement = button as HTMLElement;\n\n    // Oculta spans visuais do PrimeNG para o script do EqualWeb.\n    const visualSpans = buttonElement.querySelectorAll(`span:not([${this.equalWebSpanMarker}])`);\n    visualSpans.forEach((span: Element) => {\n      this.renderer.setAttribute(span, 'aria-hidden', 'true');\n    });\n\n    const existingSrOnly = buttonElement.querySelector(`span[${this.equalWebSpanMarker}=\"true\"]`);\n\n    // Não mantém texto extra em botões desabilitados.\n    if (isDisabled) {\n      if (existingSrOnly) {\n        this.renderer.removeChild(buttonElement, existingSrOnly);\n      }\n      return;\n    }\n\n    if (existingSrOnly) {\n      this.renderer.removeAttribute(existingSrOnly, 'tabindex');\n      this.renderer.setProperty(existingSrOnly, 'textContent', accessibleText);\n      return;\n    }\n\n    const srOnlySpan = this.renderer.createElement('span');\n    this.renderer.addClass(srOnlySpan, 'sr-only');\n    this.renderer.setAttribute(srOnlySpan, this.equalWebSpanMarker, 'true');\n    this.renderer.removeAttribute(srOnlySpan, 'tabindex');\n    const srOnlyText = this.renderer.createText(accessibleText);\n    this.renderer.appendChild(srOnlySpan, srOnlyText);\n    this.renderer.appendChild(buttonElement, srOnlySpan);\n  }\n\n  private observePaginatorChanges() {\n    const paginatorElement = this.el.nativeElement.querySelector('p-paginator');\n    if (!paginatorElement) {\n      return;\n    }\n\n    this.observedPaginatorElement = paginatorElement;\n\n    // Observa mudanças no paginador (quando botões são habilitados/desabilitados)\n    this.observer = new MutationObserver(() => {\n      this.updateWithObserverPaused();\n    });\n\n    this.startObserving();\n  }\n\n  private updateWithObserverPaused() {\n    if (!this.observer || this.isObserverPaused) {\n      return;\n    }\n\n    this.isObserverPaused = true;\n    this.observer.disconnect();\n\n    try {\n      this.updatePaginatorButtons();\n    } finally {\n      this.startObserving();\n      this.isObserverPaused = false;\n    }\n  }\n\n  private startObserving() {\n    if (!this.observer || !this.observedPaginatorElement) {\n      return;\n    }\n\n    this.observer.observe(this.observedPaginatorElement, {\n      attributes: true,\n      childList: true,\n      subtree: true,\n      attributeFilter: ['disabled', 'class', 'tabindex']\n    });\n  }\n}\n"]}

package/esm2022/shared/lib/accessibility/table-checkbox-accessibility.directive.mjs

@@ -0,0 +1,174 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Diretiva para corrigir a acessibilidade de checkboxes em tabelas PrimeNG.
+ *
+ * Propaga o `aria-label` dos custom elements wrapper (`p-tablecheckbox` e
+ * `p-tableheadercheckbox`) para os `<input type="checkbox">` internos e
+ * remove o atributo do wrapper, eliminando as violações WCAG 4.1.2:
+ * - `label` (crítica): input sem nome acessível
+ * - `aria-prohibited-attr` (séria): aria-label em custom element sem role ARIA
+ *
+ * Remove também o `aria-label` do `p-checkbox` intermediário e monitora
+ * mutations de atributo para re-aplicar o label correto caso o binding
+ * interno do PrimeNG sobrescreva o valor no input via change detection.
+ *
+ * Utiliza MutationObserver para tratar linhas adicionadas dinamicamente
+ * (paginação, lazy loading).
+ *
+ * Uso: `<p-table sTableCheckboxAccessibility ...>`
+ */
+export class TableCheckboxAccessibilityDirective {
+    el;
+    childListObserver = null;
+    attributeObserver = null;
+    isChildListPaused = false;
+    isAttributePaused = false;
+    observedElements = [];
+    inputLabelMap = new Map();
+    static CHECKBOX_SELECTOR = 'p-tablecheckbox, p-tableheadercheckbox';
+    static INNER_CHECKBOX_SELECTOR = 'p-checkbox';
+    static INPUT_SELECTOR = 'input[type="checkbox"]';
+    static ARIA_LABEL_ATTR = 'aria-label';
+    constructor(el) {
+        this.el = el;
+    }
+    ngOnInit() {
+        setTimeout(() => {
+            this.updateCheckboxLabels();
+            this.observeTableChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.childListObserver?.disconnect();
+        this.attributeObserver?.disconnect();
+        this.inputLabelMap.clear();
+    }
+    updateCheckboxLabels() {
+        const host = this.el.nativeElement;
+        const checkboxWrappers = host.querySelectorAll(TableCheckboxAccessibilityDirective.CHECKBOX_SELECTOR);
+        checkboxWrappers.forEach((wrapper) => {
+            const wrapperAriaLabel = wrapper.getAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);
+            if (!wrapperAriaLabel?.trim()) {
+                return;
+            }
+            const input = wrapper.querySelector(TableCheckboxAccessibilityDirective.INPUT_SELECTOR);
+            if (!input) {
+                return;
+            }
+            this.applyLabelToInput(input, wrapperAriaLabel);
+            wrapper.removeAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);
+            this.removeInnerCheckboxAriaLabel(wrapper);
+        });
+    }
+    applyLabelToInput(input, label) {
+        this.inputLabelMap.set(input, label);
+        input.setAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR, label);
+    }
+    removeInnerCheckboxAriaLabel(wrapper) {
+        const innerCheckbox = wrapper.querySelector(TableCheckboxAccessibilityDirective.INNER_CHECKBOX_SELECTOR);
+        if (innerCheckbox) {
+            innerCheckbox.removeAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);
+        }
+    }
+    observeTableChanges() {
+        const host = this.el.nativeElement;
+        const tbody = host.querySelector('tbody');
+        const thead = host.querySelector('thead');
+        if (tbody) {
+            this.observedElements.push(tbody);
+        }
+        if (thead) {
+            this.observedElements.push(thead);
+        }
+        if (this.observedElements.length === 0) {
+            return;
+        }
+        this.childListObserver = new MutationObserver(() => {
+            this.handleChildListMutation();
+        });
+        this.attributeObserver = new MutationObserver((mutations) => {
+            this.handleAttributeMutations(mutations);
+        });
+        this.startObserving();
+    }
+    handleAttributeMutations(mutations) {
+        if (this.isAttributePaused) {
+            return;
+        }
+        this.isAttributePaused = true;
+        try {
+            mutations
+                .filter((m) => m.attributeName === TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR)
+                .forEach((mutation) => {
+                const target = mutation.target;
+                const tagName = target.tagName?.toLowerCase();
+                if (tagName === 'p-checkbox') {
+                    target.removeAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);
+                }
+                else if (tagName === 'input') {
+                    this.enforceInputLabel(target);
+                }
+                else {
+                    // Outros elementos não precisam de tratamento
+                }
+            });
+        }
+        finally {
+            this.isAttributePaused = false;
+        }
+    }
+    enforceInputLabel(input) {
+        const correctLabel = this.inputLabelMap.get(input);
+        if (!correctLabel) {
+            return;
+        }
+        const currentLabel = input.getAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);
+        if (currentLabel !== correctLabel) {
+            input.setAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR, correctLabel);
+        }
+    }
+    handleChildListMutation() {
+        if (!this.childListObserver || this.isChildListPaused) {
+            return;
+        }
+        this.isChildListPaused = true;
+        this.childListObserver.disconnect();
+        try {
+            this.updateCheckboxLabels();
+        }
+        finally {
+            this.startObserving();
+            this.isChildListPaused = false;
+        }
+    }
+    startObserving() {
+        const { childListObserver, attributeObserver, observedElements } = this;
+        if (!childListObserver) {
+            return;
+        }
+        observedElements.forEach((element) => {
+            childListObserver.observe(element, {
+                childList: true,
+                subtree: true,
+            });
+            if (attributeObserver) {
+                attributeObserver.observe(element, {
+                    attributes: true,
+                    subtree: true,
+                    attributeFilter: [TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR],
+                });
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableCheckboxAccessibilityDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableCheckboxAccessibilityDirective, isStandalone: true, selector: "[sTableCheckboxAccessibility]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableCheckboxAccessibilityDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sTableCheckboxAccessibility]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-checkbox-accessibility.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/shared/src/lib/accessibility/table-checkbox-accessibility.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, OnInit, OnDestroy } from '@angular/core';\n\n/**\n * Diretiva para corrigir a acessibilidade de checkboxes em tabelas PrimeNG.\n *\n * Propaga o `aria-label` dos custom elements wrapper (`p-tablecheckbox` e\n * `p-tableheadercheckbox`) para os `<input type=\"checkbox\">` internos e\n * remove o atributo do wrapper, eliminando as violações WCAG 4.1.2:\n * - `label` (crítica): input sem nome acessível\n * - `aria-prohibited-attr` (séria): aria-label em custom element sem role ARIA\n *\n * Remove também o `aria-label` do `p-checkbox` intermediário e monitora\n * mutations de atributo para re-aplicar o label correto caso o binding\n * interno do PrimeNG sobrescreva o valor no input via change detection.\n *\n * Utiliza MutationObserver para tratar linhas adicionadas dinamicamente\n * (paginação, lazy loading).\n *\n * Uso: `<p-table sTableCheckboxAccessibility ...>`\n */\n@Directive({\n    selector: '[sTableCheckboxAccessibility]',\n    standalone: true,\n})\nexport class TableCheckboxAccessibilityDirective implements OnInit, OnDestroy {\n    private childListObserver: MutationObserver | null = null;\n    private attributeObserver: MutationObserver | null = null;\n    private isChildListPaused = false;\n    private isAttributePaused = false;\n    private readonly observedElements: Element[] = [];\n    private readonly inputLabelMap = new Map<Element, string>();\n\n    private static readonly CHECKBOX_SELECTOR = 'p-tablecheckbox, p-tableheadercheckbox';\n    private static readonly INNER_CHECKBOX_SELECTOR = 'p-checkbox';\n    private static readonly INPUT_SELECTOR = 'input[type=\"checkbox\"]';\n    private static readonly ARIA_LABEL_ATTR = 'aria-label';\n\n    constructor(private readonly el: ElementRef<HTMLElement>) {}\n\n    ngOnInit() {\n        setTimeout(() => {\n            this.updateCheckboxLabels();\n            this.observeTableChanges();\n        });\n    }\n\n    ngOnDestroy() {\n        this.childListObserver?.disconnect();\n        this.attributeObserver?.disconnect();\n        this.inputLabelMap.clear();\n    }\n\n    private updateCheckboxLabels() {\n        const host = this.el.nativeElement;\n        const checkboxWrappers = host.querySelectorAll(TableCheckboxAccessibilityDirective.CHECKBOX_SELECTOR);\n\n        checkboxWrappers.forEach((wrapper) => {\n            const wrapperAriaLabel = wrapper.getAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);\n            if (!wrapperAriaLabel?.trim()) {\n                return;\n            }\n\n            const input = wrapper.querySelector(TableCheckboxAccessibilityDirective.INPUT_SELECTOR);\n            if (!input) {\n                return;\n            }\n\n            this.applyLabelToInput(input, wrapperAriaLabel);\n            wrapper.removeAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);\n            this.removeInnerCheckboxAriaLabel(wrapper);\n        });\n    }\n\n    private applyLabelToInput(input: Element, label: string) {\n        this.inputLabelMap.set(input, label);\n        input.setAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR, label);\n    }\n\n    private removeInnerCheckboxAriaLabel(wrapper: Element) {\n        const innerCheckbox = wrapper.querySelector(TableCheckboxAccessibilityDirective.INNER_CHECKBOX_SELECTOR);\n        if (innerCheckbox) {\n            innerCheckbox.removeAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);\n        }\n    }\n\n    private observeTableChanges() {\n        const host = this.el.nativeElement;\n        const tbody = host.querySelector('tbody');\n        const thead = host.querySelector('thead');\n\n        if (tbody) {\n            this.observedElements.push(tbody);\n        }\n        if (thead) {\n            this.observedElements.push(thead);\n        }\n\n        if (this.observedElements.length === 0) {\n            return;\n        }\n\n        this.childListObserver = new MutationObserver(() => {\n            this.handleChildListMutation();\n        });\n\n        this.attributeObserver = new MutationObserver((mutations) => {\n            this.handleAttributeMutations(mutations);\n        });\n\n        this.startObserving();\n    }\n\n    private handleAttributeMutations(mutations: MutationRecord[]) {\n        if (this.isAttributePaused) {\n            return;\n        }\n\n        this.isAttributePaused = true;\n\n        try {\n            mutations\n                .filter((m) => m.attributeName === TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR)\n                .forEach((mutation) => {\n                    const target = mutation.target as Element;\n                    const tagName = target.tagName?.toLowerCase();\n\n                    if (tagName === 'p-checkbox') {\n                        target.removeAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);\n                    } else if (tagName === 'input') {\n                        this.enforceInputLabel(target);\n                    } else {\n                        // Outros elementos não precisam de tratamento\n                    }\n                });\n        } finally {\n            this.isAttributePaused = false;\n        }\n    }\n\n    private enforceInputLabel(input: Element) {\n        const correctLabel = this.inputLabelMap.get(input);\n        if (!correctLabel) {\n            return;\n        }\n\n        const currentLabel = input.getAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR);\n        if (currentLabel !== correctLabel) {\n            input.setAttribute(TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR, correctLabel);\n        }\n    }\n\n    private handleChildListMutation() {\n        if (!this.childListObserver || this.isChildListPaused) {\n            return;\n        }\n\n        this.isChildListPaused = true;\n        this.childListObserver.disconnect();\n\n        try {\n            this.updateCheckboxLabels();\n        } finally {\n            this.startObserving();\n            this.isChildListPaused = false;\n        }\n    }\n\n    private startObserving() {\n        const { childListObserver, attributeObserver, observedElements } = this;\n\n        if (!childListObserver) {\n            return;\n        }\n\n        observedElements.forEach((element) => {\n            childListObserver.observe(element, {\n                childList: true,\n                subtree: true,\n            });\n\n            if (attributeObserver) {\n                attributeObserver.observe(element, {\n                    attributes: true,\n                    subtree: true,\n                    attributeFilter: [TableCheckboxAccessibilityDirective.ARIA_LABEL_ATTR],\n                });\n            }\n        });\n    }\n}\n"]}

package/esm2022/shared/public-api.mjs

@@ -1,5 +1,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 { 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9zaGFyZWQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9EQUFvRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQ3JGLGNBQWMsc0JBQXNCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEJvcmRlckJ1dHRvbk9wdGlvbnMgfSBmcm9tIFwiLi9saWIvc2hhcmVkL21vZGVscy9ib3JkZXItYnV0dG9uLW9wdGlvbnNcIjtcbmV4cG9ydCB0eXBlIHsgU2V2ZXJpdGllcyB9IGZyb20gXCIuL2xpYi9zaGFyZWQvbW9kZWxzL3NldmVyaXRpZXNcIjtcbmV4cG9ydCB7IEVudW1TZXZlcml0eSB9IGZyb20gXCIuL2xpYi9zaGFyZWQvbW9kZWxzL3NldmVyaXRpZXNcIjtcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbkNvbXBvbmVudCB9IGZyb20gXCIuL2xpYi9zaGFyZWQvYm9yZGVyLWJ1dHRvbi9ib3JkZXItYnV0dG9uLmNvbXBvbmVudFwiO1xuZXhwb3J0IHsgQm9yZGVyQnV0dG9uTW9kdWxlIH0gZnJvbSBcIi4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24ubW9kdWxlXCI7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaGFyZWQvaGVscGVycydcbiJdfQ==
+export { PaginatorAccessibilityDirective } from './lib/accessibility/paginator-accessibility.directive';
+export { TableCheckboxAccessibilityDirective } from './lib/accessibility/table-checkbox-accessibility.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9zaGFyZWQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9EQUFvRCxDQUFDO0FBQzNGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQ3JGLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sdURBQXVELENBQUM7QUFDeEcsT0FBTyxFQUFFLG1DQUFtQyxFQUFFLE1BQU0sNERBQTRELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEJvcmRlckJ1dHRvbk9wdGlvbnMgfSBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL2JvcmRlci1idXR0b24tb3B0aW9ucyc7XG5leHBvcnQgdHlwZSB7IFNldmVyaXRpZXMgfSBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL3NldmVyaXRpZXMnO1xuZXhwb3J0IHsgRW51bVNldmVyaXR5IH0gZnJvbSAnLi9saWIvc2hhcmVkL21vZGVscy9zZXZlcml0aWVzJztcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbkNvbXBvbmVudCB9IGZyb20gJy4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24uY29tcG9uZW50JztcbmV4cG9ydCB7IEJvcmRlckJ1dHRvbk1vZHVsZSB9IGZyb20gJy4vbGliL3NoYXJlZC9ib3JkZXItYnV0dG9uL2JvcmRlci1idXR0b24ubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9oZWxwZXJzJztcbmV4cG9ydCB7IFBhZ2luYXRvckFjY2Vzc2liaWxpdHlEaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9hY2Nlc3NpYmlsaXR5L3BhZ2luYXRvci1hY2Nlc3NpYmlsaXR5LmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBUYWJsZUNoZWNrYm94QWNjZXNzaWJpbGl0eURpcmVjdGl2ZSB9IGZyb20gJy4vbGliL2FjY2Vzc2liaWxpdHkvdGFibGUtY2hlY2tib3gtYWNjZXNzaWJpbGl0eS5kaXJlY3RpdmUnO1xuXG4iXX0=

package/esm2022/switch/lib/switch/switch.component.mjs

@@ -17,12 +17,14 @@ import * as i1 from "@angular/common";
 export class SwitchComponent {
     /** @description Impede alterações pelo usuário sem desabilitar o campo. @default false */
     readonly = false;
-    /** @description Rótulo exibido quando o valor é `true`. */
-    trueLabel;
-    /** @description Rótulo exibido quando o valor é `false`. */
-    falseLabel;
+    /** @description Rótulo exibido quando o valor é `true`. @default 'Ligado' */
+    trueLabel = 'Ligado';
+    /** @description Rótulo exibido quando o valor é `false`. @default 'Desligado' */
+    falseLabel = 'Desligado';
     /** @description `id` do elemento `<input>` interno para associação com `<label>`. */
     inputId;
+    /** @description Nome acessível descritivo do switch para tecnologias assistivas (aria-label). */
+    label;
     /** @description Atributo `name` do `<input>` interno. */
     inputName;
     /** @description Desabilita o componente, impedindo interação e alterações. @default false */
@@ -31,6 +33,8 @@ export class SwitchComponent {
     valueChanged = new EventEmitter();
     /** @description Valor atual do switch. @default false */
     value = false;
+    /** @description Controla se deve ou não exibir o value do componente. @default true */
+    showStatusLabel = true;
     switchRef;
     _onChange;
     _onTouched;
@@ -57,6 +61,9 @@ export class SwitchComponent {
         this.disabled = disabled;
     }
     toggleCheck() {
+        if (this.readonly) {
+            return;
+        }
         this.value = !this.value;
         this.valueChanged.emit(this.value);
         if (this._onChange) {
@@ -67,13 +74,13 @@ export class SwitchComponent {
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SwitchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SwitchComponent, selector: "s-switch", inputs: { readonly: "readonly", trueLabel: "trueLabel", falseLabel: "falseLabel", inputId: "inputId", inputName: "inputName", disabled: "disabled", value: "value" }, outputs: { valueChanged: "valueChanged" }, host: { listeners: { "focusin": "onFocusIn()", "focusout": "onFocusOut()" } }, providers: [
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SwitchComponent, selector: "s-switch", inputs: { readonly: "readonly", trueLabel: "trueLabel", falseLabel: "falseLabel", inputId: "inputId", label: "label", inputName: "inputName", disabled: "disabled", value: "value", showStatusLabel: "showStatusLabel" }, outputs: { valueChanged: "valueChanged" }, host: { listeners: { "focusin": "onFocusIn()", "focusout": "onFocusOut()" } }, providers: [
             {
                 provide: NG_VALUE_ACCESSOR,
                 useExisting: forwardRef(() => SwitchComponent),
                 multi: true,
             },
-        ], viewQueries: [{ propertyName: "switchRef", first: true, predicate: ["switch"], descendants: true, static: true }], ngImport: i0, template: "<div\n    #switch\n    class=\"switch\"\n    [ngClass]=\"{ 'switch--disabled': disabled }\"\n>\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            [name]=\"inputName\"\n            type=\"checkbox\"\n            [checked]=\"value\"\n            [disabled]=\"readonly || disabled\"\n            (change)=\"toggleCheck()\"\n        />\n        <span class=\"slider\"></span>\n    </label>\n    <span class=\"label\">\n        {{ value ? trueLabel : falseLabel }}\n    </span>\n</div>\n", styles: [".switch{display:inline-flex;align-items:center}.switch .switch-toggle{display:inline-block;height:24px;margin:0;position:relative;width:40px}.switch .switch-toggle input{height:0;opacity:0;width:0}.switch .switch-toggle input:checked+.slider{background-color:#428bca;border-radius:15px}.switch .switch-toggle input:checked+.slider:before{transform:translate(16px)}.switch .switch-toggle .slider{background-color:#a5a5b2;border-radius:15px;cursor:pointer;inset:0;position:absolute;transition:.4s}.switch .switch-toggle .slider:before{background-color:#fff;border-radius:50%;bottom:4px;content:\"\";height:16px;left:4px;position:absolute;transition:.4s;width:16px}.switch .label{color:#212533;font-family:\"Open Sans\" sans-serif;font-size:.875rem;font-weight:400;line-height:150%;margin-left:12px}.switch--disabled{opacity:.5}.switch--focus .switch-toggle .slider{box-shadow:0 0 0 2px #428bca80}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+        ], viewQueries: [{ propertyName: "switchRef", first: true, predicate: ["switch"], descendants: true, static: true }], ngImport: i0, template: "<div\n    #switch\n    class=\"switch\"\n    [ngClass]=\"{ 'switch--disabled': disabled }\"\n    [attr.aria-disabled]=\"disabled || null\"\n>\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            [name]=\"inputName\"\n            type=\"checkbox\"\n            role=\"switch\"\n            [attr.aria-checked]=\"value\"\n            [attr.aria-label]=\"label || null\"\n            [checked]=\"value\"\n            [disabled]=\"disabled\"\n            [attr.aria-readonly]=\"readonly || null\"\n            (change)=\"toggleCheck()\"\n        />\n        <span\n            class=\"slider\"\n            aria-hidden=\"true\"\n        ></span>\n    </label>\n    @if (showStatusLabel) {\n        <span class=\"label\">{{ value ? trueLabel : falseLabel }}</span>\n    }\n</div>\n\n", styles: [".switch{display:inline-flex;align-items:center}.switch .switch-toggle{display:inline-block;height:24px;margin:0;position:relative;width:40px}.switch .switch-toggle input{height:0;opacity:0;width:0}.switch .switch-toggle input:focus-visible+.slider{box-shadow:0 0 0 2px #000;outline:2px solid #000;outline-offset:1px}.switch .switch-toggle input:checked+.slider{background-color:#428bca;border-radius:15px}.switch .switch-toggle input:checked+.slider:before{transform:translate(16px)}.switch .switch-toggle .slider{background-color:#a5a5b2;border-radius:15px;cursor:pointer;inset:0;position:absolute;transition:.4s}.switch .switch-toggle .slider:before{background-color:#fff;border-radius:50%;bottom:4px;content:\"\";height:16px;left:4px;position:absolute;transition:.4s;width:16px}.switch .label{color:#212533;font-family:\"Open Sans\" sans-serif;font-size:.875rem;font-weight:400;line-height:150%;margin-left:12px}.switch .label.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border-width:0}.switch--disabled{opacity:.5}.switch--focus .switch-toggle .slider{box-shadow:0 0 0 2px #428bca80}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SwitchComponent, decorators: [{
             type: Component,
@@ -83,7 +90,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                             useExisting: forwardRef(() => SwitchComponent),
                             multi: true,
                         },
-                    ], template: "<div\n    #switch\n    class=\"switch\"\n    [ngClass]=\"{ 'switch--disabled': disabled }\"\n>\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            [name]=\"inputName\"\n            type=\"checkbox\"\n            [checked]=\"value\"\n            [disabled]=\"readonly || disabled\"\n            (change)=\"toggleCheck()\"\n        />\n        <span class=\"slider\"></span>\n    </label>\n    <span class=\"label\">\n        {{ value ? trueLabel : falseLabel }}\n    </span>\n</div>\n", styles: [".switch{display:inline-flex;align-items:center}.switch .switch-toggle{display:inline-block;height:24px;margin:0;position:relative;width:40px}.switch .switch-toggle input{height:0;opacity:0;width:0}.switch .switch-toggle input:checked+.slider{background-color:#428bca;border-radius:15px}.switch .switch-toggle input:checked+.slider:before{transform:translate(16px)}.switch .switch-toggle .slider{background-color:#a5a5b2;border-radius:15px;cursor:pointer;inset:0;position:absolute;transition:.4s}.switch .switch-toggle .slider:before{background-color:#fff;border-radius:50%;bottom:4px;content:\"\";height:16px;left:4px;position:absolute;transition:.4s;width:16px}.switch .label{color:#212533;font-family:\"Open Sans\" sans-serif;font-size:.875rem;font-weight:400;line-height:150%;margin-left:12px}.switch--disabled{opacity:.5}.switch--focus .switch-toggle .slider{box-shadow:0 0 0 2px #428bca80}\n"] }]
+                    ], template: "<div\n    #switch\n    class=\"switch\"\n    [ngClass]=\"{ 'switch--disabled': disabled }\"\n    [attr.aria-disabled]=\"disabled || null\"\n>\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            [name]=\"inputName\"\n            type=\"checkbox\"\n            role=\"switch\"\n            [attr.aria-checked]=\"value\"\n            [attr.aria-label]=\"label || null\"\n            [checked]=\"value\"\n            [disabled]=\"disabled\"\n            [attr.aria-readonly]=\"readonly || null\"\n            (change)=\"toggleCheck()\"\n        />\n        <span\n            class=\"slider\"\n            aria-hidden=\"true\"\n        ></span>\n    </label>\n    @if (showStatusLabel) {\n        <span class=\"label\">{{ value ? trueLabel : falseLabel }}</span>\n    }\n</div>\n\n", styles: [".switch{display:inline-flex;align-items:center}.switch .switch-toggle{display:inline-block;height:24px;margin:0;position:relative;width:40px}.switch .switch-toggle input{height:0;opacity:0;width:0}.switch .switch-toggle input:focus-visible+.slider{box-shadow:0 0 0 2px #000;outline:2px solid #000;outline-offset:1px}.switch .switch-toggle input:checked+.slider{background-color:#428bca;border-radius:15px}.switch .switch-toggle input:checked+.slider:before{transform:translate(16px)}.switch .switch-toggle .slider{background-color:#a5a5b2;border-radius:15px;cursor:pointer;inset:0;position:absolute;transition:.4s}.switch .switch-toggle .slider:before{background-color:#fff;border-radius:50%;bottom:4px;content:\"\";height:16px;left:4px;position:absolute;transition:.4s;width:16px}.switch .label{color:#212533;font-family:\"Open Sans\" sans-serif;font-size:.875rem;font-weight:400;line-height:150%;margin-left:12px}.switch .label.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border-width:0}.switch--disabled{opacity:.5}.switch--focus .switch-toggle .slider{box-shadow:0 0 0 2px #428bca80}\n"] }]
         }], propDecorators: { readonly: [{
                 type: Input
             }], trueLabel: [{
@@ -92,6 +99,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 type: Input
             }], inputId: [{
                 type: Input
+            }], label: [{
+                type: Input
             }], inputName: [{
                 type: Input
             }], disabled: [{
@@ -100,6 +109,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 type: Output
             }], value: [{
                 type: Input
+            }], showStatusLabel: [{
+                type: Input
             }], switchRef: [{
                 type: ViewChild,
                 args: ['switch', { static: true }]
@@ -110,4 +121,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                 type: HostListener,
                 args: ['focusout']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch.component.js","sourceRoot":"","sources":["../../../../../projects/angular-components/switch/src/lib/switch/switch.component.ts","../../../../../projects/angular-components/switch/src/lib/switch/switch.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACxH,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;;;AAEzE;;;;;;;;;;;GAWG;AAaH,MAAM,OAAO,eAAe;IACxB,0FAA0F;IAEnF,QAAQ,GAAG,KAAK,CAAC;IAExB,2DAA2D;IAEpD,SAAS,CAAU;IAE1B,4DAA4D;IAErD,UAAU,CAAU;IAE3B,qFAAqF;IAE9E,OAAO,CAAU;IAExB,yDAAyD;IAElD,SAAS,CAAU;IAE1B,6FAA6F;IAEtF,QAAQ,GAAG,KAAK,CAAC;IAExB,sFAAsF;IAE/E,YAAY,GAAG,IAAI,YAAY,EAAW,CAAC;IAElD,yDAAyD;IAElD,KAAK,GAAG,KAAK,CAAC;IAGd,SAAS,CAAc;IAEtB,SAAS,CAA4B;IACrC,UAAU,CAA4B;IAGvC,SAAS;QACZ,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,aAA+B,CAAC;QACrE,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IACjD,CAAC;IAGM,UAAU;QACb,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,aAA+B,CAAC;QACrE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IACpD,CAAC;IAEM,UAAU,CAAC,KAAc;QAC5B,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACvB,CAAC;IACL,CAAC;IAEM,gBAAgB,CAAC,QAAkC;QACtD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC9B,CAAC;IAEM,iBAAiB,CAAC,SAAmC;QACxD,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAChC,CAAC;IAEM,gBAAgB,CAAE,QAAiB;QACtC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAEM,WAAW;QACd,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEnC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;IACL,CAAC;wGAhFQ,eAAe;4FAAf,eAAe,mUARb;YACP;gBACI,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC;gBAC9C,KAAK,EAAE,IAAI;aACd;SACJ,6ICzBL,qiBAqBA;;4FDMa,eAAe;kBAZ3B,SAAS;+BACI,UAAU,aAGT;wBACP;4BACI,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,gBAAgB,CAAC;4BAC9C,KAAK,EAAE,IAAI;yBACd;qBACJ;8BAKM,QAAQ;sBADd,KAAK;gBAKC,SAAS;sBADf,KAAK;gBAKC,UAAU;sBADhB,KAAK;gBAKC,OAAO;sBADb,KAAK;gBAKC,SAAS;sBADf,KAAK;gBAKC,QAAQ;sBADd,KAAK;gBAKC,YAAY;sBADlB,MAAM;gBAKA,KAAK;sBADX,KAAK;gBAIC,SAAS;sBADf,SAAS;uBAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAO9B,SAAS;sBADf,YAAY;uBAAC,SAAS;gBAOhB,UAAU;sBADhB,YAAY;uBAAC,UAAU","sourcesContent":["import { Component, ElementRef, EventEmitter, HostListener, Input, Output, ViewChild, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\n/**\n * @description Componente de chave tipo switch (liga/desliga) que implementa\n * `ControlValueAccessor` para uso em formulários Angular. Suporta rótulos\n * personalizados para os estados verdadeiro e falso, além de modo somente leitura.\n *\n * @example\n * ```html\n * <s-switch formControlName=\"ativo\" trueLabel=\"Ativo\" falseLabel=\"Inativo\" />\n * ```\n *\n * @category Inputs\n */\n@Component({\n    selector: 's-switch',\n    templateUrl: './switch.component.html',\n    styleUrls: ['./switch.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => SwitchComponent),\n            multi: true,\n        },\n    ],\n})\nexport class SwitchComponent implements ControlValueAccessor {\n    /** @description Impede alterações pelo usuário sem desabilitar o campo. @default false */\n    @Input()\n    public readonly = false;\n\n    /** @description Rótulo exibido quando o valor é `true`. */\n    @Input()\n    public trueLabel?: string;\n\n    /** @description Rótulo exibido quando o valor é `false`. */\n    @Input()\n    public falseLabel?: string;\n\n    /** @description `id` do elemento `<input>` interno para associação com `<label>`. */\n    @Input()\n    public inputId?: string;\n\n    /** @description Atributo `name` do `<input>` interno. */\n    @Input()\n    public inputName?: string;\n\n    /** @description Desabilita o componente, impedindo interação e alterações. @default false */\n    @Input()\n    public disabled = false;\n\n    /** @description Emitido quando o valor do switch muda, com o novo estado booleano. */\n    @Output()\n    public valueChanged = new EventEmitter<boolean>();\n\n    /** @description Valor atual do switch. @default false */\n    @Input()\n    public value = false;\n\n    @ViewChild('switch', { static: true })\n    public switchRef!: ElementRef;\n\n    private _onChange?: (value: boolean) => void;\n    private _onTouched?: (value: boolean) => void;\n\n    @HostListener('focusin')\n    public onFocusIn(): void {\n        const switchElement = this.switchRef.nativeElement as HTMLDivElement;\n        switchElement.classList.add('switch--focus');\n    }\n\n    @HostListener('focusout')\n    public onFocusOut(): void {\n        const switchElement = this.switchRef.nativeElement as HTMLDivElement;\n        switchElement.classList.remove('switch--focus');\n    }\n\n    public writeValue(value: boolean): void {\n        if (!this.disabled) {\n            this.value = value;\n        }\n    }\n\n    public registerOnChange(onChange: (value: boolean) => void): void {\n        this._onChange = onChange;\n    }\n\n    public registerOnTouched(onTouched: (value: boolean) => void): void {\n        this._onTouched = onTouched;\n    }\n\n    public setDisabledState?(disabled: boolean): void {\n        this.disabled = disabled;\n    }\n\n    public toggleCheck() {\n        this.value = !this.value;\n        this.valueChanged.emit(this.value);\n\n        if (this._onChange) {\n            this._onChange(this.value);\n        }\n\n        if (this._onTouched) {\n            this._onTouched(this.value);\n        }\n    }\n}\n\n","<div\n    #switch\n    class=\"switch\"\n    [ngClass]=\"{ 'switch--disabled': disabled }\"\n>\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            [name]=\"inputName\"\n            type=\"checkbox\"\n            [checked]=\"value\"\n            [disabled]=\"readonly || disabled\"\n            (change)=\"toggleCheck()\"\n        />\n        <span class=\"slider\"></span>\n    </label>\n    <span class=\"label\">\n        {{ value ? trueLabel : falseLabel }}\n    </span>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch.component.js","sourceRoot":"","sources":["../../../../../projects/angular-components/switch/src/lib/switch/switch.component.ts","../../../../../projects/angular-components/switch/src/lib/switch/switch.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, HostListener, Input, Output, ViewChild, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\n/**\n * @description Componente de chave tipo switch (liga/desliga) que implementa\n * `ControlValueAccessor` para uso em formulários Angular. Suporta rótulos\n * personalizados para os estados verdadeiro e falso, além de modo somente leitura.\n *\n * @example\n * ```html\n * <s-switch formControlName=\"ativo\" trueLabel=\"Ativo\" falseLabel=\"Inativo\" />\n * ```\n *\n * @category Inputs\n */\n@Component({\n    selector: 's-switch',\n    templateUrl: './switch.component.html',\n    styleUrls: ['./switch.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => SwitchComponent),\n            multi: true,\n        },\n    ],\n})\nexport class SwitchComponent implements ControlValueAccessor {\n    /** @description Impede alterações pelo usuário sem desabilitar o campo. @default false */\n    @Input()\n    public readonly = false;\n\n    /** @description Rótulo exibido quando o valor é `true`. @default 'Ligado' */\n    @Input()\n    public trueLabel = 'Ligado';\n\n    /** @description Rótulo exibido quando o valor é `false`. @default 'Desligado' */\n    @Input()\n    public falseLabel = 'Desligado';\n\n    /** @description `id` do elemento `<input>` interno para associação com `<label>`. */\n    @Input()\n    public inputId?: string;\n    /** @description Nome acessível descritivo do switch para tecnologias assistivas (aria-label). */\n    @Input()\n    public label?: string;\n\n    /** @description Atributo `name` do `<input>` interno. */\n    @Input()\n    public inputName?: string;\n\n    /** @description Desabilita o componente, impedindo interação e alterações. @default false */\n    @Input()\n    public disabled = false;\n\n    /** @description Emitido quando o valor do switch muda, com o novo estado booleano. */\n    @Output()\n    public valueChanged = new EventEmitter<boolean>();\n\n    /** @description Valor atual do switch. @default false */\n    @Input()\n    public value = false;\n\n    /** @description Controla se deve ou não exibir o value do componente. @default true */\n    @Input()\n    public showStatusLabel = true;\n\n    @ViewChild('switch', { static: true })\n    public switchRef!: ElementRef;\n\n    private _onChange?: (value: boolean) => void;\n    private _onTouched?: (value: boolean) => void;\n\n    @HostListener('focusin')\n    public onFocusIn(): void {\n        const switchElement = this.switchRef.nativeElement as HTMLDivElement;\n        switchElement.classList.add('switch--focus');\n    }\n\n    @HostListener('focusout')\n    public onFocusOut(): void {\n        const switchElement = this.switchRef.nativeElement as HTMLDivElement;\n        switchElement.classList.remove('switch--focus');\n    }\n\n    public writeValue(value: boolean): void {\n        if (!this.disabled) {\n            this.value = value;\n        }\n    }\n\n    public registerOnChange(onChange: (value: boolean) => void): void {\n        this._onChange = onChange;\n    }\n\n    public registerOnTouched(onTouched: (value: boolean) => void): void {\n        this._onTouched = onTouched;\n    }\n\n    public setDisabledState?(disabled: boolean): void {\n        this.disabled = disabled;\n    }\n\n    public toggleCheck() {\n        if (this.readonly) {\n            return;\n        }\n        this.value = !this.value;\n        this.valueChanged.emit(this.value);\n\n        if (this._onChange) {\n            this._onChange(this.value);\n        }\n\n        if (this._onTouched) {\n            this._onTouched(this.value);\n        }\n    }\n}\n\n","<div\n    #switch\n    class=\"switch\"\n    [ngClass]=\"{ 'switch--disabled': disabled }\"\n    [attr.aria-disabled]=\"disabled || null\"\n>\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            [name]=\"inputName\"\n            type=\"checkbox\"\n            role=\"switch\"\n            [attr.aria-checked]=\"value\"\n            [attr.aria-label]=\"label || null\"\n            [checked]=\"value\"\n            [disabled]=\"disabled\"\n            [attr.aria-readonly]=\"readonly || null\"\n            (change)=\"toggleCheck()\"\n        />\n        <span\n            class=\"slider\"\n            aria-hidden=\"true\"\n        ></span>\n    </label>\n    @if (showStatusLabel) {\n        <span class=\"label\">{{ value ? trueLabel : falseLabel }}</span>\n    }\n</div>\n\n"]}

package/esm2022/table/lib/table/table-paging/table-paging.component.mjs

@@ -295,7 +295,7 @@ export class TablePagingComponent {
         return tableData;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TablePagingComponent, deps: [{ token: i1.TranslateService }, { token: HostProjectConfigsInjectionToken }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TablePagingComponent, selector: "s-table-paging", inputs: { totalRecords: "totalRecords", exportFileName: "exportFileName", table: "table", exportable: "exportable", enableExportSelectedRecords: "enableExportSelectedRecords", customActions: "customActions", loadAllRecords: "loadAllRecords", loadCurrentPageRecords: "loadCurrentPageRecords", loadSelectedRecords: "loadSelectedRecords" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"paging-container\">\n    <span class=\"total-records\">\n        {{ totalRecordsText }}\n    </span>\n    @if (exportable) {\n        <s-button\n            class=\"export-button\"\n            priority=\"default\"\n            iconClass=\"fa fa-fw fa-file-export\"\n            [disabled]=\"false\"\n            [auxiliary]=\"true\"\n            [tooltip]=\"getTooltipText()\"\n            [menuOptions]=\"getActions()\"\n        >\n        </s-button>\n    }\n</div>\n", styles: [".paging-container{display:flex;align-items:center}.export-button{margin-left:6px}\n"], dependencies: [{ kind: "component", type: i2.ButtonComponent, selector: "s-button", inputs: ["id", "label", "tooltip", "tooltipPosition", "iconClass", "rightIconClass", "caret", "styleClass", "baseZIndex", "disabled", "auxiliary", "type", "priority", "menuOptions", "menuAriaLabel", "size", "slide", "animation", "badge", "iconColor"], outputs: ["clicked"] }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: TablePagingComponent, selector: "s-table-paging", inputs: { totalRecords: "totalRecords", exportFileName: "exportFileName", table: "table", exportable: "exportable", enableExportSelectedRecords: "enableExportSelectedRecords", customActions: "customActions", loadAllRecords: "loadAllRecords", loadCurrentPageRecords: "loadCurrentPageRecords", loadSelectedRecords: "loadSelectedRecords" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"paging-container\">\n    <span class=\"total-records\">\n        {{ totalRecordsText }}\n    </span>\n    @if (exportable) {\n        <s-button\n            class=\"export-button\"\n            priority=\"default\"\n            iconClass=\"fa fa-fw fa-file-export\"\n            [disabled]=\"false\"\n            [auxiliary]=\"true\"\n            [tooltip]=\"getTooltipText()\"\n            [menuOptions]=\"getActions()\"\n        >\n        </s-button>\n    }\n</div>\n", styles: [".paging-container{display:flex;align-items:center}.export-button{margin-left:6px}\n"], dependencies: [{ kind: "component", type: i2.ButtonComponent, selector: "s-button", inputs: ["id", "label", "tooltip", "tooltipPosition", "iconClass", "rightIconClass", "caret", "styleClass", "baseZIndex", "disabled", "auxiliary", "type", "priority", "menuOptions", "size", "slide", "animation", "badge", "iconColor", "menuAriaLabel"], outputs: ["clicked"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TablePagingComponent, decorators: [{
             type: Component,

package/esm2022/table/public-api.mjs

@@ -3,4 +3,5 @@ export * from './lib/table/row-toggler/row-toggler.directive';
 export * from './lib/table/table-column/index';
 export * from './lib/table/table-paging/index';
 export * from './lib/table/table.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy90YWJsZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi90YWJsZS9uYXZpZ2F0aW9uL25hdmlnYXRpb24uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RhYmxlL3Jvdy10b2dnbGVyL3Jvdy10b2dnbGVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90YWJsZS90YWJsZS1jb2x1bW4vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGFibGUvdGFibGUtcGFnaW5nL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RhYmxlL3RhYmxlLm1vZHVsZSc7XG4iXX0=
+export { ExportUtils } from './lib/table/export-utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy90YWJsZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvdGFibGUvbmF2aWdhdGlvbi9uYXZpZ2F0aW9uLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90YWJsZS9yb3ctdG9nZ2xlci9yb3ctdG9nZ2xlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGFibGUvdGFibGUtY29sdW1uL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RhYmxlL3RhYmxlLXBhZ2luZy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90YWJsZS90YWJsZS5tb2R1bGUnO1xuZXhwb3J0IHsgRXhwb3J0VXRpbHMgfSBmcm9tICcuL2xpYi90YWJsZS9leHBvcnQtdXRpbHMnO1xuIl19