@seniorsistemas/angular-components 17.31.2 → 18.0.0-develop-ae6477c0

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

@@ -0,0 +1,325 @@
+import { Component, Inject, Input } from '@angular/core';
+import { ExportUtils } from '../export-utils';
+import { deepClone, isNullOrUndefined } from '@seniorsistemas/angular-components/utils';
+import { LocaleService } from '@seniorsistemas/angular-components/locale';
+import { HostProjectConfigsInjectionToken } from '@seniorsistemas/angular-components/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@seniorsistemas/angular-components/button";
+export class TablePagingComponent {
+    translate;
+    hostProjectConfigs;
+    totalRecords;
+    exportFileName;
+    table;
+    exportable = true;
+    enableExportSelectedRecords = true;
+    customActions;
+    loadAllRecords;
+    loadCurrentPageRecords;
+    loadSelectedRecords;
+    totalRecordsText = '';
+    localeService = Inject(LocaleService);
+    constructor(translate, hostProjectConfigs) {
+        this.translate = translate;
+        this.hostProjectConfigs = hostProjectConfigs;
+    }
+    ngOnChanges(changes) {
+        if (changes['totalRecords']?.currentValue) {
+            this.totalRecordsText = this.translate.instant(`${this.getTranslatePrefix()}total_records`, {
+                value: changes['totalRecords'].currentValue,
+            });
+        }
+    }
+    getTranslatePrefix() {
+        return `${this.hostProjectConfigs.domain}.${this.hostProjectConfigs.service}.`;
+    }
+    getTooltipText() {
+        return this.translate.instant(`${this.getTranslatePrefix()}export_to_csv`);
+    }
+    getActions() {
+        const actions = [
+            {
+                dataKey: 'exportCurrentPage',
+                label: this.translate.instant(`${this.getTranslatePrefix()}export_current_page`),
+                command: () => this.exportCurrentPage(),
+            },
+        ];
+        if (this.enableExportSelectedRecords) {
+            actions.push({
+                dataKey: 'exportSelected',
+                label: this.translate.instant(`${this.getTranslatePrefix()}export_selected_records`),
+                command: () => this.exportSelectedRecords(),
+            });
+        }
+        if (this.loadAllRecords) {
+            actions.push({
+                dataKey: 'exportAll',
+                label: this.translate.instant(`${this.getTranslatePrefix()}export_all_records`),
+                command: () => this.exportAllRecords(),
+            });
+        }
+        if (this.customActions?.length) {
+            const customMenus = this.customActions.map((p, $index) => ({
+                dataKey: `customAction_${$index}`,
+                label: p.label,
+                command: p.command,
+            }));
+            actions.push(...customMenus);
+        }
+        return actions;
+    }
+    validateComponent() {
+        if (!this.table) {
+            throw new Error('Table component not defined');
+        }
+    }
+    getColumnsToExport() {
+        return [...(this.table.columns ?? [])].map((column) => {
+            const exportColumn = {
+                ...column,
+                header: column.header,
+                exportable: true,
+                field: column.field,
+                separator: column.separator ?? ' - ',
+                enumPrefix: column.enumPrefix,
+                customExport: column.customExport,
+            };
+            if (column.exportable === false) {
+                exportColumn.exportable = false;
+            }
+            if (column.attributes && column.attributes.length) {
+                if (column.attributes.length === 1) {
+                    exportColumn.field = column.attributes[0];
+                }
+                else {
+                    exportColumn.field = column.attributes;
+                }
+            }
+            return exportColumn;
+        });
+    }
+    getCurrentPageRowsToExport(columns) {
+        let tableData = deepClone(this.table.value);
+        if (this.loadCurrentPageRecords) {
+            tableData = this.loadCurrentPageRecords();
+        }
+        tableData = this.mapNumberFormatOptionsExport(columns, tableData);
+        return this.mapColumnsTranslations(columns, tableData);
+    }
+    getSelectedRowsToExport(columns) {
+        let tableData = deepClone(this.table.selection);
+        if (this.loadSelectedRecords) {
+            tableData = this.loadSelectedRecords();
+        }
+        tableData = this.mapNumberFormatOptionsExport(columns, tableData);
+        return this.mapColumnsTranslations(columns, tableData);
+    }
+    getPropertyValue(obj, path) {
+        return path
+            .split('.')
+            .reduce((result, prop) => (result[prop] === undefined ? undefined : result[prop]), obj);
+    }
+    setPropertyValue(obj, path, value) {
+        this.recursionSetValue(obj, path.split('.'), value);
+    }
+    recursionSetValue(obj, keysList, value) {
+        const key = keysList[0];
+        if (keysList.length === 1) {
+            obj[key] = value;
+            return obj;
+        }
+        obj[key] = this.recursionSetValue(obj?.[key] || {}, keysList.slice(1), value);
+        return obj;
+    }
+    mapColumnsTranslations(columns, rows) {
+        const enumColumns = columns.filter((p) => p.enumPrefix);
+        if (!enumColumns.length) {
+            return rows;
+        }
+        return [...rows].map((row) => {
+            const newRow = { ...row };
+            enumColumns.forEach((column) => {
+                const fields = !Array.isArray(column.field) ? [column.field] : column.field;
+                fields.forEach((fieldName) => {
+                    const columnData = this.getPropertyValue(row, fieldName);
+                    if (columnData === null || columnData === undefined) {
+                        return;
+                    }
+                    const newValue = this.translateValue(column, columnData);
+                    this.setPropertyValue(newRow, fieldName, newValue);
+                });
+            });
+            return newRow;
+        });
+    }
+    mapCustomExport(columns, rows) {
+        const customColumns = columns.filter((p) => p.customExport);
+        if (!customColumns.length) {
+            return rows;
+        }
+        return [...rows].map((row) => {
+            const newRow = { ...row };
+            customColumns.forEach((column) => {
+                const fields = !Array.isArray(column.field) ? [column.field] : column.field;
+                fields.forEach((fieldName) => {
+                    const columnData = this.getPropertyValue(row, fieldName);
+                    if (columnData === null || columnData === undefined) {
+                        return;
+                    }
+                    const newValue = column.customExport(columnData);
+                    this.setPropertyValue(newRow, fieldName, newValue);
+                });
+            });
+            return newRow;
+        });
+    }
+    translateValue(column, columnData) {
+        // Default usage: ENUM_VALUE -> domain.service.enum_value
+        const enumValue = columnData.toString().toLowerCase();
+        let translationKey = column.enumPrefix + enumValue;
+        let translatedValue = this.translate.instant(translationKey);
+        // Custom usage 1: V9 -> domain.service.v_9
+        if (translationKey === translatedValue && enumValue.length > 1) {
+            translationKey = `${column.enumPrefix}${enumValue.substring(0, 1)}_${enumValue.substr(1)}`;
+            translatedValue = this.translate.instant(translationKey);
+        }
+        // Custom usage 2: EnumValue -> domain.service.enum_value
+        if (translationKey === translatedValue) {
+            const enumKey = this.convertToSnakeCase(columnData.toString());
+            translationKey = `${column.enumPrefix}${enumKey}`;
+            translatedValue = this.translate.instant(translationKey);
+        }
+        return translatedValue;
+    }
+    convertToSnakeCase(str) {
+        return str.replace(/([A-Z])/g, (_match, group) => `_${group.toLowerCase()}`).replace(/^_/, '');
+    }
+    getExportFileName() {
+        const lang = this.translate.currentLang ?? 'pt-BR';
+        const date = new Date();
+        const fileName = this.exportFileName ?? 'download';
+        const formattedDate = date.toLocaleDateString(lang).replace('_', '-');
+        const formattedTime = date.toLocaleTimeString(lang).replace(' ', '-');
+        return `${fileName}_${formattedDate}_${formattedTime}`;
+    }
+    exportCurrentPage() {
+        this.validateComponent();
+        const columns = this.getColumnsToExport();
+        const dataToExport = this.getCurrentPageRowsToExport(columns);
+        ExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());
+    }
+    exportSelectedRecords() {
+        this.validateComponent();
+        const columns = this.getColumnsToExport();
+        const dataToExport = this.getSelectedRowsToExport(columns);
+        ExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());
+    }
+    async exportAllRecords() {
+        this.validateComponent();
+        if (!this.loadAllRecords) {
+            return;
+        }
+        let serverData = await this.loadAllRecords();
+        const columns = this.getColumnsToExport();
+        serverData = this.mapCustomExport(columns, serverData);
+        serverData = this.mapNumberFormatOptionsExport(columns, serverData);
+        const dataToExport = this.mapColumnsTranslations(columns, serverData);
+        ExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());
+    }
+    /**
+     * The purpose of this method is to map values
+     * from the TableColumnsComponent, which uses the numberFormatOptions
+     * field, along with rows that have a custom numberFormatOptions,
+     * to ensure the correct values are exported by the TablePagingComponent.
+     *
+     * @returns Returns the correctly mapped tableData.
+     */
+    mapNumberFormatOptionsExport(columns, tableData) {
+        const hasNumberFormatOptionsColumns = columns.some((column) => column.numberFormatOptions);
+        const hasNumberFormatOptionsRows = tableData.some((rowData) => Object.keys(rowData).some((key) => rowData[key]?.options?.numberFormatOptions));
+        if (!hasNumberFormatOptionsColumns && !hasNumberFormatOptionsRows)
+            return tableData;
+        if (hasNumberFormatOptionsColumns) {
+            tableData = tableData.map((rowData) => {
+                const columnsWithNumberFormatOptions = columns.filter((column) => column.numberFormatOptions);
+                for (const column of columnsWithNumberFormatOptions) {
+                    const attributes = column.attributes;
+                    const numberFormatOptions = typeof column.numberFormatOptions === 'function'
+                        ? column.numberFormatOptions({
+                            rowData,
+                        })
+                        : column.numberFormatOptions;
+                    for (const attribute of attributes) {
+                        if (isNullOrUndefined(rowData[attribute]))
+                            continue;
+                        if (rowData[attribute].options?.numberFormatOptions) {
+                            continue;
+                        }
+                        const value = rowData[attribute];
+                        const mappedValue = numberFormatOptions?.style === 'percent'
+                            ? new BigNumber(value).times(100)
+                            : new BigNumber(value);
+                        const numberFormat = new Intl.NumberFormat(this.localeService.getLocaleOptions().locale, {
+                            ...numberFormatOptions,
+                            style: 'decimal',
+                            useGrouping: false,
+                            roundingMode: 'trunc',
+                        });
+                        rowData[attribute] = numberFormat.format(mappedValue.toNumber());
+                    }
+                }
+                return rowData;
+            });
+        }
+        if (hasNumberFormatOptionsRows) {
+            tableData = tableData.map((rowData) => {
+                const keysWithNumberFormatOptions = Object.keys(rowData).filter((key) => rowData[key]?.options?.numberFormatOptions);
+                for (const key of keysWithNumberFormatOptions) {
+                    const value = rowData[key].value;
+                    const numberFormatOptions = rowData[key].options?.numberFormatOptions;
+                    const mappedValue = numberFormatOptions?.style === 'percent'
+                        ? new BigNumber(value).times(100)
+                        : new BigNumber(value);
+                    const numberFormat = new Intl.NumberFormat(this.localeService.getLocaleOptions().locale, {
+                        ...numberFormatOptions,
+                        style: 'decimal',
+                        useGrouping: false,
+                        roundingMode: 'trunc',
+                    });
+                    rowData[key] = numberFormat.format(mappedValue.toNumber());
+                }
+                return rowData;
+            });
+        }
+        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", "size", "slide", "animation", "badge", "iconColor"], outputs: ["clicked"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TablePagingComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-table-paging', 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"] }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HostProjectConfigsInjectionToken]
+                }] }], propDecorators: { totalRecords: [{
+                type: Input
+            }], exportFileName: [{
+                type: Input
+            }], table: [{
+                type: Input
+            }], exportable: [{
+                type: Input
+            }], enableExportSelectedRecords: [{
+                type: Input
+            }], customActions: [{
+                type: Input
+            }], loadAllRecords: [{
+                type: Input
+            }], loadCurrentPageRecords: [{
+                type: Input
+            }], loadSelectedRecords: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-paging.component.js","sourceRoot":"","sources":["../../../../../../projects/angular-components/table/src/lib/table/table-paging/table-paging.component.ts","../../../../../../projects/angular-components/table/src/lib/table/table-paging/table-paging.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Inject, Input, OnChanges, SimpleChanges } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Table } from 'primeng/table';\nimport { CustomAction } from './models';\nimport { Column } from '../table-column/models';\nimport { ExportUtils } from '../export-utils';\nimport { deepClone, isNullOrUndefined } from '@seniorsistemas/angular-components/utils';\nimport { LocaleService } from '@seniorsistemas/angular-components/locale';\nimport { TieredMenuItemData } from '@seniorsistemas/angular-components/tiered-menu';\nimport { HostProjectConfigs, HostProjectConfigsInjectionToken } from '@seniorsistemas/angular-components/common';\n\ntype RowValueFormatOption = {\n    value?: number;\n    options?: {\n        numberFormatOptions?: Intl.NumberFormatOptions;\n    };\n};\n\n@Component({\n    templateUrl: './table-paging.component.html',\n    styleUrls: ['./table-paging.component.scss'],\n    selector: 's-table-paging',\n})\nexport class TablePagingComponent implements OnChanges {\n    @Input()\n    public totalRecords!: number;\n\n    @Input()\n    public exportFileName?: string;\n\n    @Input()\n    public table!: Table;\n\n    @Input()\n    public exportable = true;\n\n    @Input()\n    public enableExportSelectedRecords = true;\n\n    @Input()\n    public customActions?: CustomAction[];\n\n    @Input()\n    public loadAllRecords?: () => Promise<any[]>;\n\n    @Input()\n    public loadCurrentPageRecords?: () => any[];\n\n    @Input()\n    public loadSelectedRecords?: () => any[];\n\n    public totalRecordsText = '';\n\n    private readonly localeService: LocaleService = Inject(LocaleService);\n\n    constructor(\n        private readonly translate: TranslateService,\n        @Inject(HostProjectConfigsInjectionToken) private readonly hostProjectConfigs: HostProjectConfigs,\n    ) {}\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (changes['totalRecords']?.currentValue) {\n            this.totalRecordsText = this.translate.instant(`${this.getTranslatePrefix()}total_records`, {\n                value: changes['totalRecords'].currentValue,\n            });\n        }\n    }\n\n    private getTranslatePrefix() {\n        return `${this.hostProjectConfigs.domain}.${this.hostProjectConfigs.service}.`;\n    }\n\n    public getTooltipText() {\n        return this.translate.instant(`${this.getTranslatePrefix()}export_to_csv`);\n    }\n\n    public getActions(): TieredMenuItemData[] {\n        const actions: TieredMenuItemData[] = [\n            {\n                dataKey: 'exportCurrentPage',\n                label: this.translate.instant(`${this.getTranslatePrefix()}export_current_page`),\n                command: () => this.exportCurrentPage(),\n            },\n        ];\n\n        if (this.enableExportSelectedRecords) {\n            actions.push({\n                dataKey: 'exportSelected',\n                label: this.translate.instant(`${this.getTranslatePrefix()}export_selected_records`),\n                command: () => this.exportSelectedRecords(),\n            });\n        }\n\n        if (this.loadAllRecords) {\n            actions.push({\n                dataKey: 'exportAll',\n                label: this.translate.instant(`${this.getTranslatePrefix()}export_all_records`),\n                command: () => this.exportAllRecords(),\n            });\n        }\n\n        if (this.customActions?.length) {\n            const customMenus = this.customActions.map((p, $index) => ({\n                dataKey: `customAction_${$index}`,\n                label: p.label,\n                command: p.command,\n            }));\n            actions.push(...customMenus);\n        }\n\n        return actions;\n    }\n\n    private validateComponent() {\n        if (!this.table) {\n            throw new Error('Table component not defined');\n        }\n    }\n\n    public getColumnsToExport() {\n        return [...(this.table.columns ?? [])].map((column) => {\n            const exportColumn = {\n                ...column,\n                header: column.header,\n                exportable: true,\n                field: column.field,\n                separator: column.separator ?? ' - ',\n                enumPrefix: column.enumPrefix,\n                customExport: column.customExport,\n            };\n\n            if (column.exportable === false) {\n                exportColumn.exportable = false;\n            }\n\n            if (column.attributes && column.attributes.length) {\n                if (column.attributes.length === 1) {\n                    exportColumn.field = column.attributes[0];\n                } else {\n                    exportColumn.field = column.attributes;\n                }\n            }\n\n            return exportColumn;\n        });\n    }\n\n    private getCurrentPageRowsToExport(columns: any[]) {\n        let tableData = deepClone(this.table.value);\n\n        if (this.loadCurrentPageRecords) {\n            tableData = this.loadCurrentPageRecords();\n        }\n\n        tableData = this.mapNumberFormatOptionsExport(columns, tableData);\n        return this.mapColumnsTranslations(columns, tableData);\n    }\n\n    private getSelectedRowsToExport(columns: any[]) {\n        let tableData = deepClone(this.table.selection);\n        if (this.loadSelectedRecords) {\n            tableData = this.loadSelectedRecords();\n        }\n\n        tableData = this.mapNumberFormatOptionsExport(columns, tableData);\n        return this.mapColumnsTranslations(columns, tableData);\n    }\n\n    private getPropertyValue(obj: any, path: string) {\n        return path\n            .split('.')\n            .reduce((result: any, prop: any) => (result[prop] === undefined ? undefined : result[prop]), obj);\n    }\n\n    private setPropertyValue(obj: any, path: string, value: any) {\n        this.recursionSetValue(obj, path.split('.'), value);\n    }\n\n    private recursionSetValue(obj: any, keysList: string[], value: any): any {\n        const key = keysList[0];\n        if (keysList.length === 1) {\n            obj[key] = value;\n            return obj;\n        }\n        obj[key] = this.recursionSetValue(obj?.[key] || {}, keysList.slice(1), value);\n        return obj;\n    }\n\n    public mapColumnsTranslations(columns: any[], rows: any[]) {\n        const enumColumns = columns.filter((p) => p.enumPrefix);\n        if (!enumColumns.length) {\n            return rows;\n        }\n\n        return [...rows].map((row) => {\n            const newRow = { ...row };\n            enumColumns.forEach((column) => {\n                const fields = !Array.isArray(column.field) ? [column.field] : column.field;\n                fields.forEach((fieldName: string) => {\n                    const columnData = this.getPropertyValue(row, fieldName);\n                    if (columnData === null || columnData === undefined) {\n                        return;\n                    }\n\n                    const newValue = this.translateValue(column, columnData);\n                    this.setPropertyValue(newRow, fieldName, newValue);\n                });\n            });\n\n            return newRow;\n        });\n    }\n\n    public mapCustomExport(columns: any[], rows: any[]) {\n        const customColumns = columns.filter((p) => p.customExport);\n        if (!customColumns.length) {\n            return rows;\n        }\n\n        return [...rows].map((row) => {\n            const newRow = { ...row };\n            customColumns.forEach((column) => {\n                const fields = !Array.isArray(column.field) ? [column.field] : column.field;\n                fields.forEach((fieldName: string) => {\n                    const columnData = this.getPropertyValue(row, fieldName);\n                    if (columnData === null || columnData === undefined) {\n                        return;\n                    }\n                    const newValue = column.customExport(columnData);\n                    this.setPropertyValue(newRow, fieldName, newValue);\n                });\n            });\n\n            return newRow;\n        });\n    }\n\n    private translateValue(column: any, columnData: any) {\n        // Default usage: ENUM_VALUE -> domain.service.enum_value\n        const enumValue = columnData.toString().toLowerCase();\n        let translationKey = column.enumPrefix + enumValue;\n        let translatedValue = this.translate.instant(translationKey);\n\n        // Custom usage 1: V9 -> domain.service.v_9\n        if (translationKey === translatedValue && enumValue.length > 1) {\n            translationKey = `${column.enumPrefix}${enumValue.substring(0, 1)}_${enumValue.substr(1)}`;\n            translatedValue = this.translate.instant(translationKey);\n        }\n\n        // Custom usage 2: EnumValue -> domain.service.enum_value\n        if (translationKey === translatedValue) {\n            const enumKey = this.convertToSnakeCase(columnData.toString());\n            translationKey = `${column.enumPrefix}${enumKey}`;\n            translatedValue = this.translate.instant(translationKey);\n        }\n\n        return translatedValue;\n    }\n\n    private convertToSnakeCase(str: string) {\n        return str.replace(/([A-Z])/g, (_match, group) => `_${group.toLowerCase()}`).replace(/^_/, '');\n    }\n\n    private getExportFileName() {\n        const lang = this.translate.currentLang ?? 'pt-BR';\n        const date = new Date();\n\n        const fileName = this.exportFileName ?? 'download';\n        const formattedDate = date.toLocaleDateString(lang).replace('_', '-');\n        const formattedTime = date.toLocaleTimeString(lang).replace(' ', '-');\n\n        return `${fileName}_${formattedDate}_${formattedTime}`;\n    }\n\n    public exportCurrentPage() {\n        this.validateComponent();\n        const columns = this.getColumnsToExport();\n        const dataToExport = this.getCurrentPageRowsToExport(columns);\n        ExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());\n    }\n\n    public exportSelectedRecords() {\n        this.validateComponent();\n        const columns = this.getColumnsToExport();\n        const dataToExport = this.getSelectedRowsToExport(columns);\n        ExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());\n    }\n\n    public async exportAllRecords() {\n        this.validateComponent();\n\n        if (!this.loadAllRecords) {\n            return;\n        }\n        let serverData = await this.loadAllRecords();\n\n        const columns = this.getColumnsToExport();\n\n        serverData = this.mapCustomExport(columns, serverData);\n\n        serverData = this.mapNumberFormatOptionsExport(columns, serverData);\n\n        const dataToExport = this.mapColumnsTranslations(columns, serverData);\n\n        ExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());\n    }\n\n    /**\n     * The purpose of this method is to map values\n     * from the TableColumnsComponent, which uses the numberFormatOptions\n     * field, along with rows that have a custom numberFormatOptions,\n     * to ensure the correct values are exported by the TablePagingComponent.\n     *\n     * @returns Returns the correctly mapped tableData.\n     */\n    public mapNumberFormatOptionsExport(\n        columns: Partial<Column>[],\n        tableData: {\n            [key: string]: RowValueFormatOption | number | string | null | undefined;\n        }[],\n    ) {\n        const hasNumberFormatOptionsColumns = columns.some((column) => column.numberFormatOptions);\n        const hasNumberFormatOptionsRows = tableData.some((rowData) =>\n            Object.keys(rowData).some((key) => (rowData[key] as RowValueFormatOption)?.options?.numberFormatOptions),\n        );\n\n        if (!hasNumberFormatOptionsColumns && !hasNumberFormatOptionsRows) return tableData;\n\n        if (hasNumberFormatOptionsColumns) {\n            tableData = tableData.map((rowData) => {\n                const columnsWithNumberFormatOptions = columns.filter((column) => column.numberFormatOptions);\n\n                for (const column of columnsWithNumberFormatOptions) {\n                    const attributes = column.attributes;\n\n                    const numberFormatOptions =\n                        typeof column.numberFormatOptions === 'function'\n                            ? column.numberFormatOptions({\n                                  rowData,\n                              })\n                            : column.numberFormatOptions;\n\n                    for (const attribute of attributes!) {\n                        if (isNullOrUndefined(rowData[attribute as string])) continue;\n\n                        if ((rowData[attribute as string] as RowValueFormatOption).options?.numberFormatOptions) {\n                            continue;\n                        }\n\n                        const value = rowData[attribute as string] as string | number;\n\n                        const mappedValue =\n                            numberFormatOptions?.style === 'percent'\n                                ? new BigNumber(value).times(100)\n                                : new BigNumber(value);\n\n                        const numberFormat = new Intl.NumberFormat(this.localeService.getLocaleOptions()!.locale, {\n                            ...numberFormatOptions,\n                            style: 'decimal',\n                            useGrouping: false,\n                            roundingMode: 'trunc',\n                        } as any);\n\n                        rowData[attribute as string] = numberFormat.format(mappedValue.toNumber());\n                    }\n                }\n\n                return rowData;\n            });\n        }\n\n        if (hasNumberFormatOptionsRows) {\n            tableData = tableData.map((rowData) => {\n                const keysWithNumberFormatOptions = Object.keys(rowData).filter(\n                    (key) => (rowData[key] as RowValueFormatOption)?.options?.numberFormatOptions,\n                );\n\n                for (const key of keysWithNumberFormatOptions) {\n                    const value = (rowData[key] as RowValueFormatOption).value;\n\n                    const numberFormatOptions = (rowData[key] as RowValueFormatOption).options?.numberFormatOptions;\n\n                    const mappedValue =\n                        numberFormatOptions?.style === 'percent'\n                            ? new BigNumber(value!).times(100)\n                            : new BigNumber(value!);\n\n                    const numberFormat = new Intl.NumberFormat(this.localeService.getLocaleOptions()!.locale, {\n                        ...numberFormatOptions,\n                        style: 'decimal',\n                        useGrouping: false,\n                        roundingMode: 'trunc',\n                    } as any);\n\n                    (rowData[key] as string | number) = numberFormat.format(mappedValue.toNumber());\n                }\n\n                return rowData;\n            });\n        }\n\n        return tableData;\n    }\n}\n","<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"]}

package/esm2022/table/lib/table/table.module.mjs

@@ -0,0 +1,27 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { NavigationDirective } from './navigation/navigation.directive';
+import { RowTogllerDirective } from './row-toggler/row-toggler.directive';
+import { TableColumnsComponent } from './table-column/table-columns.component';
+import { TablePagingComponent } from './table-paging/table-paging.component';
+import { BadgeModule } from '@seniorsistemas/angular-components/badge';
+import { ButtonModule } from '@seniorsistemas/angular-components/button';
+import { InfoSignModule } from '@seniorsistemas/angular-components/info-sign';
+import { TooltipModule } from '@seniorsistemas/angular-components/tooltip';
+import { TokenListModule } from '@seniorsistemas/angular-components/token-list';
+import * as i0 from "@angular/core";
+export class TableModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TableModule, declarations: [RowTogllerDirective, NavigationDirective, TableColumnsComponent, TablePagingComponent], imports: [CommonModule, TooltipModule, TokenListModule, TranslateModule, ButtonModule, InfoSignModule, BadgeModule], exports: [RowTogllerDirective, NavigationDirective, TableColumnsComponent, TablePagingComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableModule, imports: [CommonModule, TooltipModule, TokenListModule, TranslateModule, ButtonModule, InfoSignModule, BadgeModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, TooltipModule, TokenListModule, TranslateModule, ButtonModule, InfoSignModule, BadgeModule],
+                    exports: [RowTogllerDirective, NavigationDirective, TableColumnsComponent, TablePagingComponent],
+                    declarations: [RowTogllerDirective, NavigationDirective, TableColumnsComponent, TablePagingComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL3RhYmxlL3NyYy9saWIvdGFibGUvdGFibGUubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUN4RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUMxRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUM3RSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDdkUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDJDQUEyQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNENBQTRDLENBQUM7QUFDM0UsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLCtDQUErQyxDQUFDOztBQU9oRixNQUFNLE9BQU8sV0FBVzt3R0FBWCxXQUFXO3lHQUFYLFdBQVcsaUJBRkwsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQUUscUJBQXFCLEVBQUUsb0JBQW9CLGFBRjFGLFlBQVksRUFBRSxhQUFhLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSxZQUFZLEVBQUUsY0FBYyxFQUFFLFdBQVcsYUFDeEcsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQUUscUJBQXFCLEVBQUUsb0JBQW9CO3lHQUd0RixXQUFXLFlBSlYsWUFBWSxFQUFFLGFBQWEsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsV0FBVzs7NEZBSXpHLFdBQVc7a0JBTHZCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGFBQWEsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBRSxjQUFjLEVBQUUsV0FBVyxDQUFDO29CQUNuSCxPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsRUFBRSxtQkFBbUIsRUFBRSxxQkFBcUIsRUFBRSxvQkFBb0IsQ0FBQztvQkFDaEcsWUFBWSxFQUFFLENBQUMsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQUUscUJBQXFCLEVBQUUsb0JBQW9CLENBQUM7aUJBQ3hHIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFRyYW5zbGF0ZU1vZHVsZSB9IGZyb20gJ0BuZ3gtdHJhbnNsYXRlL2NvcmUnO1xuaW1wb3J0IHsgTmF2aWdhdGlvbkRpcmVjdGl2ZSB9IGZyb20gJy4vbmF2aWdhdGlvbi9uYXZpZ2F0aW9uLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBSb3dUb2dsbGVyRGlyZWN0aXZlIH0gZnJvbSAnLi9yb3ctdG9nZ2xlci9yb3ctdG9nZ2xlci5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgVGFibGVDb2x1bW5zQ29tcG9uZW50IH0gZnJvbSAnLi90YWJsZS1jb2x1bW4vdGFibGUtY29sdW1ucy5jb21wb25lbnQnO1xuaW1wb3J0IHsgVGFibGVQYWdpbmdDb21wb25lbnQgfSBmcm9tICcuL3RhYmxlLXBhZ2luZy90YWJsZS1wYWdpbmcuY29tcG9uZW50JztcbmltcG9ydCB7IEJhZGdlTW9kdWxlIH0gZnJvbSAnQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy9iYWRnZSc7XG5pbXBvcnQgeyBCdXR0b25Nb2R1bGUgfSBmcm9tICdAc2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzL2J1dHRvbic7XG5pbXBvcnQgeyBJbmZvU2lnbk1vZHVsZSB9IGZyb20gJ0BzZW5pb3JzaXN0ZW1hcy9hbmd1bGFyLWNvbXBvbmVudHMvaW5mby1zaWduJztcbmltcG9ydCB7IFRvb2x0aXBNb2R1bGUgfSBmcm9tICdAc2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzL3Rvb2x0aXAnO1xuaW1wb3J0IHsgVG9rZW5MaXN0TW9kdWxlIH0gZnJvbSAnQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy90b2tlbi1saXN0JztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBUb29sdGlwTW9kdWxlLCBUb2tlbkxpc3RNb2R1bGUsIFRyYW5zbGF0ZU1vZHVsZSwgQnV0dG9uTW9kdWxlLCBJbmZvU2lnbk1vZHVsZSwgQmFkZ2VNb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtSb3dUb2dsbGVyRGlyZWN0aXZlLCBOYXZpZ2F0aW9uRGlyZWN0aXZlLCBUYWJsZUNvbHVtbnNDb21wb25lbnQsIFRhYmxlUGFnaW5nQ29tcG9uZW50XSxcbiAgICBkZWNsYXJhdGlvbnM6IFtSb3dUb2dsbGVyRGlyZWN0aXZlLCBOYXZpZ2F0aW9uRGlyZWN0aXZlLCBUYWJsZUNvbHVtbnNDb21wb25lbnQsIFRhYmxlUGFnaW5nQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgVGFibGVNb2R1bGUgeyB9XG4iXX0=

package/esm2022/table/public-api.mjs

@@ -0,0 +1,6 @@
+export * from './lib/table/navigation/navigation.directive';
+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=

package/esm2022/table/seniorsistemas-angular-components-table.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuaW9yc2lzdGVtYXMtYW5ndWxhci1jb21wb25lbnRzLXRhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL3RhYmxlL3NyYy9zZW5pb3JzaXN0ZW1hcy1hbmd1bGFyLWNvbXBvbmVudHMtdGFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/table-header/lib/table-header/table-header-checkbox.component.mjs

@@ -0,0 +1,151 @@
+import { Component, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/table";
+import * as i2 from "@seniorsistemas/angular-components/checkbox-list";
+import * as i3 from "@angular/forms";
+export class TableHeaderCheckboxComponent {
+    table;
+    tableService;
+    static nextId = 0;
+    id = `s-table-header-checkbox-${TableHeaderCheckboxComponent.nextId++}`;
+    disabled = false;
+    rowProps;
+    useAllObject;
+    checkboxItems = {
+        label: '',
+    };
+    checked = false;
+    hasFocus = false;
+    checkboxState = { checked: false };
+    _ngUnsubscribe = new Subject();
+    constructor(table, tableService) {
+        this.table = table;
+        this.tableService = tableService;
+        this.table.tableService.valueSource$.pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {
+            this.checked = this.updateCheckedState();
+        });
+        this.table.tableService.selectionSource$.pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {
+            this.checked = this.updateCheckedState();
+        });
+    }
+    ngOnInit() {
+        this.checked = this.updateCheckedState();
+    }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next();
+    }
+    onFocus() {
+        this.hasFocus = true;
+    }
+    onBlur() {
+        this.hasFocus = false;
+    }
+    isDisabled() {
+        return this.disabled || !this.table.value || !this.table.value.length;
+    }
+    onClick() {
+        if (!this.disabled) {
+            if (this.table.value && this.table.value.length > 0)
+                this.onToggleCheckbox(!this.checked);
+        }
+    }
+    updateCheckedState() {
+        if (this.table.filteredValue) {
+            const val = this.table.filteredValue;
+            return val && val.length > 0 && this.table.selection && this.table.selection.length > 0 && this.isAllFilteredValuesChecked();
+        }
+        else {
+            const val = this.table.value;
+            return val && val.length > 0 && this.table.selection && this.table.selection.length > 0 && this.isAllValuesChecked();
+        }
+    }
+    onToggleCheckbox(checked) {
+        const { filteredValue, value, dataKey } = this.table;
+        const gridData = checked ? (filteredValue ? filteredValue.slice() : value.slice()) : [];
+        if (!dataKey)
+            return;
+        if (checked) {
+            const unselecteds = gridData
+                .filter((record) => !this.table._selection.find((selected) => record[dataKey] === selected[dataKey]))
+                .map((record) => {
+                if (this.useAllObject)
+                    return record;
+                const newRecord = {};
+                if (this.rowProps)
+                    this.rowProps.forEach((prop) => (newRecord[prop] = record[prop]));
+                else
+                    newRecord[dataKey] = record[dataKey];
+                return newRecord;
+            });
+            this.table._selection = [...this.table._selection, ...unselecteds];
+        }
+        else {
+            value.forEach((data) => {
+                this.table._selection = this.table._selection.filter((record) => record[dataKey] !== data[dataKey]);
+            });
+        }
+        this.table.updateSelectionKeys();
+        this.table.selectionChange.emit(this.table._selection);
+        this.tableService.onSelectionChange();
+        if (this.table.isStateful())
+            this.table.saveState();
+    }
+    isAllFilteredValuesChecked() {
+        if (!this.table.filteredValue) {
+            return false;
+        }
+        else {
+            for (const rowData of this.table.filteredValue) {
+                if (!this.table.isSelected(rowData)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    isAllValuesChecked() {
+        if (!this.table.value) {
+            return false;
+        }
+        else {
+            for (const rowData of this.table.value) {
+                if (!this.table.isSelected(rowData)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableHeaderCheckboxComponent, deps: [{ token: i1.Table }, { token: i1.TableService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: TableHeaderCheckboxComponent, selector: "s-table-header-checkbox", inputs: { id: "id", disabled: "disabled", rowProps: "rowProps", useAllObject: "useAllObject" }, ngImport: i0, template: `
+        <s-checkbox-list
+            [(ngModel)]="checkboxState"
+            (ngModelChange)="onClick()"
+            [data]="checkboxItems"
+        />
+    `, isInline: true, dependencies: [{ kind: "component", type: i2.CheckboxListComponent, selector: "s-checkbox-list", inputs: ["data"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableHeaderCheckboxComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 's-table-header-checkbox',
+                    template: `
+        <s-checkbox-list
+            [(ngModel)]="checkboxState"
+            (ngModelChange)="onClick()"
+            [data]="checkboxItems"
+        />
+    `,
+                }]
+        }], ctorParameters: () => [{ type: i1.Table }, { type: i1.TableService }], propDecorators: { id: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], rowProps: [{
+                type: Input
+            }], useAllObject: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-header-checkbox.component.js","sourceRoot":"","sources":["../../../../../projects/angular-components/table-header/src/lib/table-header/table-header-checkbox.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, OnInit } from '@angular/core';\n\nimport { CheckboxListData, CheckboxListState } from '@seniorsistemas/angular-components/checkbox-list';\nimport { Table, TableService } from 'primeng/table';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n@Component({\n    selector: 's-table-header-checkbox',\n    template: `\n        <s-checkbox-list\n            [(ngModel)]=\"checkboxState\"\n            (ngModelChange)=\"onClick()\"\n            [data]=\"checkboxItems\"\n        />\n    `,\n})\nexport class TableHeaderCheckboxComponent implements OnInit, OnDestroy {\n    public static nextId = 0;\n\n    @Input()\n    public id = `s-table-header-checkbox-${TableHeaderCheckboxComponent.nextId++}`;\n\n    @Input()\n    public disabled = false;\n\n    @Input()\n    public rowProps?: string[];\n\n    @Input()\n    public useAllObject?: boolean;\n\n    public checkboxItems: CheckboxListData = {\n        label: '',\n    };\n\n    public checked = false;\n    public hasFocus = false;\n    public checkboxState: CheckboxListState = { checked: false };\n\n    private _ngUnsubscribe = new Subject<void>();\n\n    constructor(\n        public readonly table: Table,\n        public readonly tableService: TableService,\n    ) {\n        this.table.tableService.valueSource$.pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {\n            this.checked = this.updateCheckedState();\n        });\n\n        this.table.tableService.selectionSource$.pipe(takeUntil(this._ngUnsubscribe)).subscribe(() => {\n            this.checked = this.updateCheckedState();\n        });\n    }\n\n    public ngOnInit(): void {\n        this.checked = this.updateCheckedState();\n    }\n\n    public ngOnDestroy(): void {\n        this._ngUnsubscribe.next();\n    }\n\n    public onFocus(): void {\n        this.hasFocus = true;\n    }\n\n    public onBlur(): void {\n        this.hasFocus = false;\n    }\n\n    public isDisabled(): boolean {\n        return this.disabled || !this.table.value || !this.table.value.length;\n    }\n\n    public onClick(): void {\n        if (!this.disabled) {\n            if (this.table.value && this.table.value.length > 0) this.onToggleCheckbox(!this.checked);\n        }\n    }\n\n    public updateCheckedState() {\n        if (this.table.filteredValue) {\n            const val = this.table.filteredValue;\n            return val && val.length > 0 && this.table.selection && this.table.selection.length > 0 && this.isAllFilteredValuesChecked();\n        } else {\n            const val = this.table.value;\n            return val && val.length > 0 && this.table.selection && this.table.selection.length > 0 && this.isAllValuesChecked();\n        }\n    }\n\n    public onToggleCheckbox(checked: boolean): void {\n        const { filteredValue, value, dataKey } = this.table;\n        const gridData = checked ? (filteredValue ? filteredValue.slice() : value.slice()) : [];\n\n        if (!dataKey) return;\n\n        if (checked) {\n            const unselecteds = gridData\n                .filter((record) => !this.table._selection.find((selected: any) => record[dataKey] === selected[dataKey]))\n                .map((record: any) => {\n                    if (this.useAllObject) return record;\n\n                    const newRecord: any = {};\n                    if (this.rowProps) this.rowProps.forEach((prop: string) => (newRecord[prop] = record[prop]));\n                    else newRecord[dataKey] = record[dataKey];\n                    return newRecord;\n                });\n            this.table._selection = [...this.table._selection, ...unselecteds];\n        } else {\n            value.forEach((data: any) => {\n                this.table._selection = this.table._selection.filter((record: any) => record[dataKey] !== data[dataKey]);\n            });\n        }\n\n        this.table.updateSelectionKeys();\n        this.table.selectionChange.emit(this.table._selection);\n        this.tableService.onSelectionChange();\n\n        if (this.table.isStateful()) this.table.saveState();\n    }\n\n    public isAllFilteredValuesChecked(): boolean {\n        if (!this.table.filteredValue) {\n            return false;\n        } else {\n            for (const rowData of this.table.filteredValue) {\n                if (!this.table.isSelected(rowData)) {\n                    return false;\n                }\n            }\n            return true;\n        }\n    }\n\n    public isAllValuesChecked(): boolean {\n        if (!this.table.value) {\n            return false;\n        } else {\n            for (const rowData of this.table.value) {\n                if (!this.table.isSelected(rowData)) {\n                    return false;\n                }\n            }\n            return true;\n        }\n    }\n}\n"]}