@seniorsistemas/angular-components 17.27.0 → 17.27.1-bugfix-sds-407-a6968ba2

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

@@ -0,0 +1,321 @@
+import { Component, Inject, Input } from '@angular/core';
+import { ExportUtils } from '../export-utils';
+import { 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 = this.table.value;
+        if (this.loadCurrentPageRecords) {
+            tableData = this.loadCurrentPageRecords();
+        }
+        tableData = this.mapNumberFormatOptionsExport(columns, tableData);
+        return this.mapColumnsTranslations(columns, tableData);
+    }
+    getSelectedRowsToExport(columns) {
+        let tableData = 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 { 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\tvalue?: number;\n\toptions?: {\n\t\tnumberFormatOptions?: Intl.NumberFormatOptions;\n\t};\n}\n\n@Component({\n\ttemplateUrl: './table-paging.component.html',\n\tstyleUrls: ['./table-paging.component.scss'],\n\tselector: 's-table-paging',\n})\nexport class TablePagingComponent implements OnChanges {\n\t@Input()\n\tpublic totalRecords!: number;\n\n\t@Input()\n\tpublic exportFileName?: string;\n\n\t@Input()\n\tpublic table!: Table;\n\n\t@Input()\n\tpublic exportable = true;\n\n\t@Input()\n\tpublic enableExportSelectedRecords = true;\n\n\t@Input()\n\tpublic customActions?: CustomAction[];\n\n\t@Input()\n\tpublic loadAllRecords?: () => Promise<any[]>;\n\n\t@Input()\n\tpublic loadCurrentPageRecords?: () => any[];\n\n\t@Input()\n\tpublic loadSelectedRecords?: () => any[];\n\n\tpublic totalRecordsText = '';\n\n\tprivate readonly localeService: LocaleService = Inject(LocaleService)\n\n\tconstructor(\n\t\tprivate readonly translate: TranslateService,\n\t\t@Inject(HostProjectConfigsInjectionToken) private readonly hostProjectConfigs: HostProjectConfigs,\n\t) { }\n\n\tngOnChanges(changes: SimpleChanges): void {\n\t\tif (changes['totalRecords']?.currentValue) {\n\t\t\tthis.totalRecordsText = this.translate.instant(`${this.getTranslatePrefix()}total_records`, {\n\t\t\t\tvalue: changes['totalRecords'].currentValue,\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate getTranslatePrefix() {\n\t\treturn `${this.hostProjectConfigs.domain}.${this.hostProjectConfigs.service}.`;\n\t}\n\n\tpublic getTooltipText() {\n\t\treturn this.translate.instant(`${this.getTranslatePrefix()}export_to_csv`);\n\t}\n\n\tpublic getActions(): TieredMenuItemData[] {\n\t\tconst actions: TieredMenuItemData[] = [\n\t\t\t{\n\t\t\t\tdataKey: 'exportCurrentPage',\n\t\t\t\tlabel: this.translate.instant(`${this.getTranslatePrefix()}export_current_page`),\n\t\t\t\tcommand: () => this.exportCurrentPage(),\n\t\t\t},\n\t\t];\n\n\t\tif (this.enableExportSelectedRecords) {\n\t\t\tactions.push({\n\t\t\t\tdataKey: 'exportSelected',\n\t\t\t\tlabel: this.translate.instant(`${this.getTranslatePrefix()}export_selected_records`),\n\t\t\t\tcommand: () => this.exportSelectedRecords(),\n\t\t\t});\n\t\t}\n\n\t\tif (this.loadAllRecords) {\n\t\t\tactions.push({\n\t\t\t\tdataKey: 'exportAll',\n\t\t\t\tlabel: this.translate.instant(`${this.getTranslatePrefix()}export_all_records`),\n\t\t\t\tcommand: () => this.exportAllRecords(),\n\t\t\t});\n\t\t}\n\n\t\tif (this.customActions?.length) {\n\t\t\tconst customMenus = this.customActions.map((p, $index) => ({\n\t\t\t\tdataKey: `customAction_${$index}`,\n\t\t\t\tlabel: p.label,\n\t\t\t\tcommand: p.command,\n\t\t\t}));\n\t\t\tactions.push(...customMenus);\n\t\t}\n\n\t\treturn actions;\n\t}\n\n\tprivate validateComponent() {\n\t\tif (!this.table) {\n\t\t\tthrow new Error('Table component not defined');\n\t\t}\n\t}\n\n\tpublic getColumnsToExport() {\n\t\treturn [...(this.table.columns ?? [])].map((column) => {\n\t\t\tconst exportColumn = {\n\t\t\t\t...column,\n\t\t\t\theader: column.header,\n\t\t\t\texportable: true,\n\t\t\t\tfield: column.field,\n\t\t\t\tseparator: column.separator ?? ' - ',\n\t\t\t\tenumPrefix: column.enumPrefix,\n\t\t\t\tcustomExport: column.customExport,\n\t\t\t};\n\n\t\t\tif (column.exportable === false) {\n\t\t\t\texportColumn.exportable = false;\n\t\t\t}\n\n\t\t\tif (column.attributes && column.attributes.length) {\n\t\t\t\tif (column.attributes.length === 1) {\n\t\t\t\t\texportColumn.field = column.attributes[0];\n\t\t\t\t} else {\n\t\t\t\t\texportColumn.field = column.attributes;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn exportColumn;\n\t\t});\n\t}\n\n\tprivate getCurrentPageRowsToExport(columns: any[]) {\n\t\tlet tableData = this.table.value;\n\t\tif (this.loadCurrentPageRecords) {\n\t\t\ttableData = this.loadCurrentPageRecords();\n\t\t}\n\n\t\ttableData = this.mapNumberFormatOptionsExport(columns, tableData);\n\t\treturn this.mapColumnsTranslations(columns, tableData);\n\t}\n\n\tprivate getSelectedRowsToExport(columns: any[]) {\n\t\tlet tableData = this.table.selection;\n\t\tif (this.loadSelectedRecords) {\n\t\t\ttableData = this.loadSelectedRecords();\n\t\t}\n\n\t\ttableData = this.mapNumberFormatOptionsExport(columns, tableData);\n\t\treturn this.mapColumnsTranslations(columns, tableData);\n\t}\n\n\tprivate getPropertyValue(obj: any, path: string) {\n\t\treturn path\n\t\t\t.split('.')\n\t\t\t.reduce((result: any, prop: any) => (result[prop] === undefined ? undefined : result[prop]), obj);\n\t}\n\n\tprivate setPropertyValue(obj: any, path: string, value: any) {\n\t\tthis.recursionSetValue(obj, path.split('.'), value);\n\t}\n\n\tprivate recursionSetValue(obj: any, keysList: string[], value: any): any {\n\t\tconst key = keysList[0];\n\t\tif (keysList.length === 1) {\n\t\t\tobj[key] = value;\n\t\t\treturn obj;\n\t\t}\n\t\tobj[key] = this.recursionSetValue(obj?.[key] || {}, keysList.slice(1), value);\n\t\treturn obj;\n\t}\n\n\tpublic mapColumnsTranslations(columns: any[], rows: any[]) {\n\t\tconst enumColumns = columns.filter((p) => p.enumPrefix);\n\t\tif (!enumColumns.length) {\n\t\t\treturn rows;\n\t\t}\n\n\t\treturn [...rows].map((row) => {\n\t\t\tconst newRow = { ...row };\n\t\t\tenumColumns.forEach((column) => {\n\t\t\t\tconst fields = !Array.isArray(column.field) ? [column.field] : column.field;\n\t\t\t\tfields.forEach((fieldName: string) => {\n\t\t\t\t\tconst columnData = this.getPropertyValue(row, fieldName);\n\t\t\t\t\tif (columnData === null || columnData === undefined) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tconst newValue = this.translateValue(column, columnData);\n\t\t\t\t\tthis.setPropertyValue(newRow, fieldName, newValue);\n\t\t\t\t});\n\t\t\t});\n\n\t\t\treturn newRow;\n\t\t});\n\t}\n\n\tpublic mapCustomExport(columns: any[], rows: any[]) {\n\t\tconst customColumns = columns.filter((p) => p.customExport);\n\t\tif (!customColumns.length) {\n\t\t\treturn rows;\n\t\t}\n\n\t\treturn [...rows].map((row) => {\n\t\t\tconst newRow = { ...row };\n\t\t\tcustomColumns.forEach((column) => {\n\t\t\t\tconst fields = !Array.isArray(column.field) ? [column.field] : column.field;\n\t\t\t\tfields.forEach((fieldName: string) => {\n\t\t\t\t\tconst columnData = this.getPropertyValue(row, fieldName);\n\t\t\t\t\tif (columnData === null || columnData === undefined) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst newValue = column.customExport(columnData);\n\t\t\t\t\tthis.setPropertyValue(newRow, fieldName, newValue);\n\t\t\t\t});\n\t\t\t});\n\n\t\t\treturn newRow;\n\t\t});\n\t}\n\n\tprivate translateValue(column: any, columnData: any) {\n\t\t// Default usage: ENUM_VALUE -> domain.service.enum_value\n\t\tconst enumValue = columnData.toString().toLowerCase();\n\t\tlet translationKey = column.enumPrefix + enumValue;\n\t\tlet translatedValue = this.translate.instant(translationKey);\n\n\t\t// Custom usage 1: V9 -> domain.service.v_9\n\t\tif (translationKey === translatedValue && enumValue.length > 1) {\n\t\t\ttranslationKey = `${column.enumPrefix}${enumValue.substring(0, 1)}_${enumValue.substr(1)}`;\n\t\t\ttranslatedValue = this.translate.instant(translationKey);\n\t\t}\n\n\t\t// Custom usage 2: EnumValue -> domain.service.enum_value\n\t\tif (translationKey === translatedValue) {\n\t\t\tconst enumKey = this.convertToSnakeCase(columnData.toString());\n\t\t\ttranslationKey = `${column.enumPrefix}${enumKey}`;\n\t\t\ttranslatedValue = this.translate.instant(translationKey);\n\t\t}\n\n\t\treturn translatedValue;\n\t}\n\n\tprivate convertToSnakeCase(str: string) {\n\t\treturn str.replace(/([A-Z])/g, (_match, group) => `_${group.toLowerCase()}`).replace(/^_/, \"\");\n\t}\n\n\tprivate getExportFileName() {\n\t\tconst lang = this.translate.currentLang ?? 'pt-BR';\n\t\tconst date = new Date();\n\n\t\tconst fileName = this.exportFileName ?? 'download';\n\t\tconst formattedDate = date.toLocaleDateString(lang).replace('_', '-');\n\t\tconst formattedTime = date.toLocaleTimeString(lang).replace(' ', '-');\n\n\t\treturn `${fileName}_${formattedDate}_${formattedTime}`;\n\t}\n\n\tpublic exportCurrentPage() {\n\t\tthis.validateComponent();\n\t\tconst columns = this.getColumnsToExport();\n\t\tconst dataToExport = this.getCurrentPageRowsToExport(columns);\n\t\tExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());\n\t}\n\n\tpublic exportSelectedRecords() {\n\t\tthis.validateComponent();\n\t\tconst columns = this.getColumnsToExport();\n\t\tconst dataToExport = this.getSelectedRowsToExport(columns);\n\t\tExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());\n\t}\n\n\tpublic async exportAllRecords() {\n\t\tthis.validateComponent();\n\n\t\tif (!this.loadAllRecords) {\n\t\t\treturn;\n\t\t}\n\t\tlet serverData = await this.loadAllRecords();\n\n\t\tconst columns = this.getColumnsToExport();\n\n\t\tserverData = this.mapCustomExport(columns, serverData);\n\n\t\tserverData = this.mapNumberFormatOptionsExport(columns, serverData);\n\n\t\tconst dataToExport = this.mapColumnsTranslations(columns, serverData);\n\n\t\tExportUtils.exportCSV(columns, dataToExport, undefined, this.getExportFileName());\n\t}\n\n\t/**\n\t * The purpose of this method is to map values\n\t * from the TableColumnsComponent, which uses the numberFormatOptions\n\t * field, along with rows that have a custom numberFormatOptions,\n\t * to ensure the correct values are exported by the TablePagingComponent.\n\t *\n\t * @returns Returns the correctly mapped tableData.\n\t */\n\tpublic mapNumberFormatOptionsExport(\n\t\tcolumns: Partial<Column>[],\n\t\ttableData: {\n\t\t\t[key: string]: RowValueFormatOption | number | string | null | undefined;\n\t\t}[]\n\t) {\n\t\tconst hasNumberFormatOptionsColumns = columns.some((column) => column.numberFormatOptions);\n\t\tconst hasNumberFormatOptionsRows = tableData.some((rowData) =>\n\t\t\tObject.keys(rowData).some((key) => (rowData[key] as RowValueFormatOption)?.options?.numberFormatOptions)\n\t\t);\n\n\t\tif (!hasNumberFormatOptionsColumns && !hasNumberFormatOptionsRows) return tableData;\n\n\t\tif (hasNumberFormatOptionsColumns) {\n\t\t\ttableData = tableData.map((rowData) => {\n\t\t\t\tconst columnsWithNumberFormatOptions = columns.filter((column) => column.numberFormatOptions);\n\n\t\t\t\tfor (const column of columnsWithNumberFormatOptions) {\n\t\t\t\t\tconst attributes = column.attributes;\n\n\t\t\t\t\tconst numberFormatOptions =\n\t\t\t\t\t\ttypeof column.numberFormatOptions === \"function\"\n\t\t\t\t\t\t\t? column.numberFormatOptions({\n\t\t\t\t\t\t\t\trowData,\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t: column.numberFormatOptions;\n\n\t\t\t\t\tfor (const attribute of attributes!) {\n\t\t\t\t\t\tif (isNullOrUndefined(rowData[attribute as string])) continue;\n\n\t\t\t\t\t\tif ((rowData[attribute as string] as RowValueFormatOption).options?.numberFormatOptions) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tconst value = rowData[attribute as string] as string | number;\n\n\t\t\t\t\t\tconst mappedValue =\n\t\t\t\t\t\t\tnumberFormatOptions?.style === \"percent\" ? new BigNumber(value).times(100) : new BigNumber(value);\n\n\t\t\t\t\t\tconst numberFormat = new Intl.NumberFormat(this.localeService.getLocaleOptions()!.locale, {\n\t\t\t\t\t\t\t...numberFormatOptions,\n\t\t\t\t\t\t\tstyle: \"decimal\",\n\t\t\t\t\t\t\tuseGrouping: false,\n\t\t\t\t\t\t\troundingMode: \"trunc\",\n\t\t\t\t\t\t} as any);\n\n\t\t\t\t\t\trowData[attribute as string] = numberFormat.format(mappedValue.toNumber());\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn rowData;\n\t\t\t});\n\t\t}\n\n\t\tif (hasNumberFormatOptionsRows) {\n\t\t\ttableData = tableData.map((rowData) => {\n\t\t\t\tconst keysWithNumberFormatOptions = Object.keys(rowData).filter(\n\t\t\t\t\t(key) => (rowData[key] as RowValueFormatOption)?.options?.numberFormatOptions\n\t\t\t\t);\n\n\t\t\t\tfor (const key of keysWithNumberFormatOptions) {\n\t\t\t\t\tconst value = (rowData[key] as RowValueFormatOption).value;\n\n\t\t\t\t\tconst numberFormatOptions = (rowData[key] as RowValueFormatOption).options?.numberFormatOptions;\n\n\t\t\t\t\tconst mappedValue = numberFormatOptions?.style === \"percent\" ? new BigNumber(value!).times(100) : new BigNumber(value!);\n\n\t\t\t\t\tconst numberFormat = new Intl.NumberFormat(this.localeService.getLocaleOptions()!.locale, {\n\t\t\t\t\t\t...numberFormatOptions,\n\t\t\t\t\t\tstyle: \"decimal\",\n\t\t\t\t\t\tuseGrouping: false,\n\t\t\t\t\t\troundingMode: \"trunc\",\n\t\t\t\t\t} as any);\n\n\t\t\t\t\t(rowData[key] as string | number) = numberFormat.format(mappedValue.toNumber());\n\t\t\t\t}\n\n\t\t\t\treturn rowData;\n\t\t\t});\n\t\t}\n\n\t\treturn tableData;\n\t}\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,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

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":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAqB,MAAM,eAAe,CAAC;AAIpE,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;;;;;AAY3C,MAAM,OAAO,4BAA4B;IA0BjB;IACA;IA1Bb,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IAGlB,EAAE,GAAG,2BAA2B,4BAA4B,CAAC,MAAM,EAAE,EAAE,CAAC;IAGxE,QAAQ,GAAG,KAAK,CAAC;IAGjB,QAAQ,CAAY;IAGpB,YAAY,CAAW;IAEvB,aAAa,GAAqB;QACrC,KAAK,EAAE,EAAE;KACZ,CAAC;IAEK,OAAO,GAAG,KAAK,CAAC;IAChB,QAAQ,GAAG,KAAK,CAAC;IACjB,aAAa,GAAsB,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAErD,cAAc,GAAG,IAAI,OAAO,EAAQ,CAAC;IAE7C,YACoB,KAAY,EACZ,YAA0B;QAD1B,UAAK,GAAL,KAAK,CAAO;QACZ,iBAAY,GAAZ,YAAY,CAAc;QAE1C,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACrF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACzF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,QAAQ;QACX,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC7C,CAAC;IAEM,WAAW;QACd,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;IAC/B,CAAC;IAEM,OAAO;QACV,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACzB,CAAC;IAEM,MAAM;QACT,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IAC1B,CAAC;IAEM,UAAU;QACb,OAAO,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;IAC1E,CAAC;IAEM,OAAO;QACV,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACjB,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;gBAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC9F,CAAC;IACL,CAAC;IAEM,kBAAkB;QACrB,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;YAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;YACrC,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;QACjI,CAAC;aAAM,CAAC;YACJ,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;YAC7B,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACzH,CAAC;IACL,CAAC;IAEM,gBAAgB,CAAC,OAAgB;QACpC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QACrD,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAExF,IAAI,CAAC,OAAO;YAAE,OAAO;QAErB,IAAI,OAAO,EAAE,CAAC;YACV,MAAM,WAAW,GAAG,QAAQ;iBACvB,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;iBACzG,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE;gBACjB,IAAI,IAAI,CAAC,YAAY;oBAAE,OAAO,MAAM,CAAC;gBAErC,MAAM,SAAS,GAAQ,EAAE,CAAC;gBAC1B,IAAI,IAAI,CAAC,QAAQ;oBAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;oBACxF,SAAS,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;gBAC1C,OAAO,SAAS,CAAC;YACrB,CAAC,CAAC,CAAC;YACP,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,GAAG,WAAW,CAAC,CAAC;QACvE,CAAC;aAAM,CAAC;YACJ,KAAK,CAAC,OAAO,CAAC,CAAC,IAAS,EAAE,EAAE;gBACxB,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC7G,CAAC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE,CAAC;QACjC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACvD,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;QAEtC,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE;YAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;IACxD,CAAC;IAEM,0BAA0B;QAC7B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAC;QACjB,CAAC;aAAM,CAAC;YACJ,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;gBAC7C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;oBAClC,OAAO,KAAK,CAAC;gBACjB,CAAC;YACL,CAAC;YACD,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;IAEM,kBAAkB;QACrB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC;QACjB,CAAC;aAAM,CAAC;YACJ,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;gBACrC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;oBAClC,OAAO,KAAK,CAAC;gBACjB,CAAC;YACL,CAAC;YACD,OAAO,IAAI,CAAC;QAChB,CAAC;IACL,CAAC;wGAjIQ,4BAA4B;4FAA5B,4BAA4B,+JAR3B;;;;;;KAMT;;4FAEQ,4BAA4B;kBAVxC,SAAS;mBAAC;oBACP,QAAQ,EAAE,yBAAyB;oBACnC,QAAQ,EAAE;;;;;;KAMT;iBACJ;qGAKU,EAAE;sBADR,KAAK;gBAIC,QAAQ;sBADd,KAAK;gBAIC,QAAQ;sBADd,KAAK;gBAIC,YAAY;sBADlB,KAAK","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"]}