@c80/ui 1.0.31 → 1.0.33

package/esm2022/lib/table/table-data-utils.service.mjs

@@ -0,0 +1,166 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para utilidades de manipulación de datos en tablas C80
+ *
+ * Proporciona métodos para:
+ * - Acceso a valores de celdas (incluyendo propiedades anidadas)
+ * - Formateo de valores para display
+ * - Gestión de enums y colores
+ * - Ordenamiento de datos
+ */
+export class TableDataUtilsService {
+    /**
+     * Obtiene el valor de una celda usando el accessor, soportando notación de punto para propiedades anidadas
+     * @param row - La fila de datos
+     * @param accessor - El accessor de la columna
+     * @returns El valor de la celda
+     */
+    getCellValue(row, accessor) {
+        if (accessor.includes('.')) {
+            return this.getNestedValue(row, accessor);
+        }
+        return row[accessor];
+    }
+    /**
+     * Obtiene el valor de un objeto usando notación de punto (ej: 'task.name')
+     * @param obj - Objeto del cual obtener el valor
+     * @param accessor - Ruta de acceso usando notación de punto
+     * @returns El valor anidado o undefined
+     */
+    getNestedValue(obj, accessor) {
+        return accessor.split('.').reduce((current, key) => {
+            return current && typeof current === 'object' ? current[key] : undefined;
+        }, obj);
+    }
+    /**
+     * Devuelve el valor de display para una celda, mostrando '-' para valores falsy excepto 0, false y objetos/arrays vacíos
+     * @param value - Valor a formatear
+     * @returns Cadena formateada para display
+     */
+    getDisplayValue(value) {
+        // Si el valor es 0, mostrarlo
+        if (value === 0) {
+            return '0';
+        }
+        // Si el valor es false, debe ser manejado por lógica booleana en template, no aquí
+        if (value === false) {
+            return 'false';
+        }
+        // Manejar objetos y arrays (incluyendo los vacíos)
+        if (typeof value === 'object' && value !== null) {
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return '[object Object]';
+            }
+        }
+        // Si el valor son otros falsy values (null, undefined, ''), mostrar '-'
+        if (!value) {
+            return '-';
+        }
+        // Manejar otros tipos explícitamente
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean') {
+            return String(value);
+        }
+        // Para cualquier otro tipo (función, símbolo, etc.), devolver un fallback seguro
+        return '-';
+    }
+    /**
+     * Obtiene el texto de display para un valor enum
+     * @param value - Valor del enum
+     * @param col - Definición de la columna
+     * @returns Texto formateado del enum
+     */
+    getEnumDisplayValue(value, col) {
+        if (!col.enum || (value !== 0 && !value)) {
+            return '-';
+        }
+        const displayValue = col.enum[value];
+        return (displayValue ||
+            (typeof value === 'string' || typeof value === 'number'
+                ? String(value)
+                : '-'));
+    }
+    /**
+     * Obtiene las opciones del enum como array para dropdowns select
+     * @param col - Definición de la columna
+     * @returns Array de opciones con value y label
+     */
+    getEnumOptions(col) {
+        if (!col.enum)
+            return [];
+        return Object.entries(col.enum).map(([value, label]) => ({
+            value: isNaN(Number(value)) ? value : Number(value),
+            label,
+        }));
+    }
+    /**
+     * Obtiene el color CSS para un valor de celda basado en la configuración de color de la columna
+     * @param value - Valor de la celda
+     * @param col - Definición de la columna
+     * @returns Color CSS o undefined si no hay configuración
+     */
+    getCellColor(value, col) {
+        if (!col.color || (value !== 0 && !value)) {
+            return undefined;
+        }
+        return col.color[value];
+    }
+    /**
+     * Aplica ordenamiento a los items basándose en las columnas con configuración de orden
+     * @param items - Array de items a ordenar (se modifica in-place)
+     * @param columns - Definiciones de columnas
+     */
+    applySorting(items, columns) {
+        const orderedColumns = columns.filter((col) => col.order);
+        if (orderedColumns.length > 0) {
+            orderedColumns.forEach((col) => {
+                items.sort((a, b) => {
+                    const valueA = this.getCellValue(a, col.accessor);
+                    const valueB = this.getCellValue(b, col.accessor);
+                    if (col.order === 'ASC') {
+                        if (valueA > valueB)
+                            return 1;
+                        if (valueA < valueB)
+                            return -1;
+                        return 0;
+                    }
+                    else {
+                        if (valueA < valueB)
+                            return 1;
+                        if (valueA > valueB)
+                            return -1;
+                        return 0;
+                    }
+                });
+            });
+        }
+    }
+    /**
+     * Calcula el max-height de la tabla basado en el tamaño
+     * @param size - Tamaño configurado (0 = sin límite)
+     * @returns String CSS para max-height o undefined si sin límite
+     */
+    getTableMaxHeight(size) {
+        if (size <= 0) {
+            return undefined; // Sin límite de altura
+        }
+        // Altura base de 400px * size
+        const baseHeight = 400;
+        const maxHeight = Math.round(baseHeight * size);
+        return `${maxHeight}px`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableDataUtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableDataUtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableDataUtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-data-utils.service.js","sourceRoot":"","sources":["../../../../../libs/ui/src/lib/table/table-data-utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { C80TableColDef } from './table.types';\n\n/**\n * Servicio para utilidades de manipulación de datos en tablas C80\n *\n * Proporciona métodos para:\n * - Acceso a valores de celdas (incluyendo propiedades anidadas)\n * - Formateo de valores para display\n * - Gestión de enums y colores\n * - Ordenamiento de datos\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class TableDataUtilsService {\n\n    /**\n     * Obtiene el valor de una celda usando el accessor, soportando notación de punto para propiedades anidadas\n     * @param row - La fila de datos\n     * @param accessor - El accessor de la columna\n     * @returns El valor de la celda\n     */\n    getCellValue<T extends Record<string, unknown>>(row: T, accessor: string): unknown {\n        if (accessor.includes('.')) {\n            return this.getNestedValue(row, accessor);\n        }\n        return (row as Record<string, unknown>)[accessor];\n    }\n\n    /**\n     * Obtiene el valor de un objeto usando notación de punto (ej: 'task.name')\n     * @param obj - Objeto del cual obtener el valor\n     * @param accessor - Ruta de acceso usando notación de punto\n     * @returns El valor anidado o undefined\n     */\n    getNestedValue(obj: any, accessor: string): unknown {\n        return accessor.split('.').reduce((current, key) => {\n            return current && typeof current === 'object' ? current[key] : undefined;\n        }, obj);\n    }\n\n    /**\n     * Devuelve el valor de display para una celda, mostrando '-' para valores falsy excepto 0, false y objetos/arrays vacíos\n     * @param value - Valor a formatear\n     * @returns Cadena formateada para display\n     */\n    getDisplayValue(value: unknown): string {\n        // Si el valor es 0, mostrarlo\n        if (value === 0) {\n            return '0';\n        }\n        // Si el valor es false, debe ser manejado por lógica booleana en template, no aquí\n        if (value === false) {\n            return 'false';\n        }\n        // Manejar objetos y arrays (incluyendo los vacíos)\n        if (typeof value === 'object' && value !== null) {\n            try {\n                return JSON.stringify(value);\n            } catch {\n                return '[object Object]';\n            }\n        }\n        // Si el valor son otros falsy values (null, undefined, ''), mostrar '-'\n        if (!value) {\n            return '-';\n        }\n        // Manejar otros tipos explícitamente\n        if (\n            typeof value === 'string' ||\n            typeof value === 'number' ||\n            typeof value === 'boolean'\n        ) {\n            return String(value);\n        }\n        // Para cualquier otro tipo (función, símbolo, etc.), devolver un fallback seguro\n        return '-';\n    }\n\n    /**\n     * Obtiene el texto de display para un valor enum\n     * @param value - Valor del enum\n     * @param col - Definición de la columna\n     * @returns Texto formateado del enum\n     */\n    getEnumDisplayValue(value: unknown, col: C80TableColDef): string {\n        if (!col.enum || (value !== 0 && !value)) {\n            return '-';\n        }\n        const displayValue = col.enum[value as string | number];\n        return (\n            displayValue ||\n            (typeof value === 'string' || typeof value === 'number'\n                ? String(value)\n                : '-')\n        );\n    }\n\n    /**\n     * Obtiene las opciones del enum como array para dropdowns select\n     * @param col - Definición de la columna\n     * @returns Array de opciones con value y label\n     */\n    getEnumOptions(col: C80TableColDef): { value: string | number; label: string }[] {\n        if (!col.enum) return [];\n        return Object.entries(col.enum).map(([value, label]) => ({\n            value: isNaN(Number(value)) ? value : Number(value),\n            label,\n        }));\n    }\n\n    /**\n     * Obtiene el color CSS para un valor de celda basado en la configuración de color de la columna\n     * @param value - Valor de la celda\n     * @param col - Definición de la columna\n     * @returns Color CSS o undefined si no hay configuración\n     */\n    getCellColor(value: unknown, col: C80TableColDef): string | undefined {\n        if (!col.color || (value !== 0 && !value)) {\n            return undefined;\n        }\n        return col.color[value as string | number];\n    }\n\n    /**\n     * Aplica ordenamiento a los items basándose en las columnas con configuración de orden\n     * @param items - Array de items a ordenar (se modifica in-place)\n     * @param columns - Definiciones de columnas\n     */\n    applySorting<T extends Record<string, unknown>>(items: T[], columns: C80TableColDef[]): void {\n        const orderedColumns = columns.filter((col) => col.order);\n        if (orderedColumns.length > 0) {\n            orderedColumns.forEach((col) => {\n                items.sort((a, b) => {\n                    const valueA = this.getCellValue(a, col.accessor) as string | number;\n                    const valueB = this.getCellValue(b, col.accessor) as string | number;\n\n                    if (col.order === 'ASC') {\n                        if (valueA > valueB) return 1;\n                        if (valueA < valueB) return -1;\n                        return 0;\n                    } else {\n                        if (valueA < valueB) return 1;\n                        if (valueA > valueB) return -1;\n                        return 0;\n                    }\n                });\n            });\n        }\n    }\n\n    /**\n     * Calcula el max-height de la tabla basado en el tamaño\n     * @param size - Tamaño configurado (0 = sin límite)\n     * @returns String CSS para max-height o undefined si sin límite\n     */\n    getTableMaxHeight(size: number): string | undefined {\n        if (size <= 0) {\n            return undefined; // Sin límite de altura\n        }\n        // Altura base de 400px * size\n        const baseHeight = 400;\n        const maxHeight = Math.round(baseHeight * size);\n        return `${maxHeight}px`;\n    }\n}\n"]}

package/esm2022/lib/table/table-selection.service.mjs

@@ -0,0 +1,151 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar la selección de elementos en tablas C80
+ *
+ * Maneja:
+ * - Selección simple y múltiple
+ * - Estado de selección completa
+ * - Preservación de selección tras actualizaciones de datos
+ * - Emisión de eventos de selección
+ */
+export class TableSelectionService {
+    /**
+     * Inicializa el estado de selección para una nueva tabla
+     * @returns Objeto con signals y métodos de selección
+     */
+    createSelectionState() {
+        const selectedItems = signal(new Set());
+        const selectAllChecked = signal(false);
+        const selectAllIndeterminate = signal(false);
+        const clearSelection = () => {
+            selectedItems.set(new Set());
+            updateSelectAllState();
+        };
+        const updateSelectAllState = () => {
+            // Esta función será actualizada cuando se tengan los datos disponibles
+            selectAllChecked.set(false);
+            selectAllIndeterminate.set(false);
+        };
+        const toggleSelectAll = (allItems) => {
+            const currentSelection = selectedItems();
+            if (currentSelection.size === allItems.length) {
+                // Desmarcar todos los elementos
+                clearSelection();
+            }
+            else {
+                // Marcar todos los elementos
+                const allIds = new Set(allItems.map(item => item['id']));
+                selectedItems.set(allIds);
+                updateSelectAllStateWithData(allItems);
+            }
+        };
+        const toggleItemSelection = (item, multiple) => {
+            const id = item['id'];
+            const currentSelection = new Set(selectedItems());
+            if (!multiple) {
+                // Selección simple: solo permitir un elemento seleccionado
+                if (currentSelection.has(id)) {
+                    // Deseleccionar el elemento actual
+                    currentSelection.clear();
+                }
+                else {
+                    // Seleccionar solo este elemento
+                    currentSelection.clear();
+                    currentSelection.add(id);
+                }
+            }
+            else if (currentSelection.has(id)) {
+                // Selección múltiple: deseleccionar elemento existente
+                currentSelection.delete(id);
+            }
+            else {
+                // Selección múltiple: agregar nuevo elemento
+                currentSelection.add(id);
+            }
+            selectedItems.set(currentSelection);
+        };
+        const isItemSelected = (item) => {
+            const id = item['id'];
+            return selectedItems().has(id);
+        };
+        const updateSelectAllStateWithData = (allItems) => {
+            const selectedCount = selectedItems().size;
+            const totalCount = allItems.length;
+            if (selectedCount === 0) {
+                selectAllChecked.set(false);
+                selectAllIndeterminate.set(false);
+            }
+            else if (selectedCount === totalCount) {
+                selectAllChecked.set(true);
+                selectAllIndeterminate.set(false);
+            }
+            else {
+                selectAllChecked.set(false);
+                selectAllIndeterminate.set(true);
+            }
+        };
+        const preserveSelection = (newData) => {
+            const currentSelection = selectedItems();
+            if (currentSelection.size === 0 || newData.length === 0) {
+                // Si no hay selección o no hay datos, limpiar la selección
+                clearSelection();
+                return;
+            }
+            // Obtener los IDs disponibles en los nuevos datos
+            const availableIds = new Set(newData.map(item => item['id']));
+            // Filtrar la selección actual para mantener solo los IDs que aún existen
+            const preservedSelection = new Set(Array.from(currentSelection).filter(id => availableIds.has(id)));
+            // Actualizar la selección con los IDs preservados
+            selectedItems.set(preservedSelection);
+            updateSelectAllStateWithData(newData);
+        };
+        const getSelectedItems = (allData) => {
+            const selectedIds = selectedItems();
+            return allData.filter(item => selectedIds.has(item['id']));
+        };
+        // Redefinir updateSelectAllState con acceso a los datos
+        const originalUpdateSelectAllState = updateSelectAllState;
+        const updateSelectAllStateWrapper = (allItems) => {
+            if (allItems) {
+                updateSelectAllStateWithData(allItems);
+            }
+            else {
+                originalUpdateSelectAllState();
+            }
+        };
+        return {
+            // Signals
+            selectedItems: selectedItems.asReadonly(),
+            selectAllChecked: selectAllChecked.asReadonly(),
+            selectAllIndeterminate: selectAllIndeterminate.asReadonly(),
+            // Métodos
+            clearSelection,
+            toggleSelectAll,
+            toggleItemSelection,
+            isItemSelected,
+            preserveSelection,
+            getSelectedItems,
+            updateSelectAllState: updateSelectAllStateWrapper,
+        };
+    }
+    /**
+     * Emite los elementos seleccionados a través del EventEmitter proporcionado
+     * @param selectionState - Estado de selección
+     * @param allData - Todos los datos de la tabla
+     * @param selectableEmitter - EventEmitter para emitir la selección
+     */
+    emitSelection(selectionState, allData, selectableEmitter) {
+        const selectedItems = selectionState.getSelectedItems(allData);
+        selectableEmitter.emit(selectedItems);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableSelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableSelectionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableSelectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-selection.service.js","sourceRoot":"","sources":["../../../../../libs/ui/src/lib/table/table-selection.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, EventEmitter } from '@angular/core';\nimport { ID } from './table.types';\n\n/**\n * Servicio para gestionar la selección de elementos en tablas C80\n *\n * Maneja:\n * - Selección simple y múltiple\n * - Estado de selección completa\n * - Preservación de selección tras actualizaciones de datos\n * - Emisión de eventos de selección\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class TableSelectionService {\n\n    /**\n     * Inicializa el estado de selección para una nueva tabla\n     * @returns Objeto con signals y métodos de selección\n     */\n    createSelectionState<T extends Record<string, unknown>>() {\n        const selectedItems = signal<Set<ID>>(new Set());\n        const selectAllChecked = signal(false);\n        const selectAllIndeterminate = signal(false);\n\n        const clearSelection = (): void => {\n            selectedItems.set(new Set());\n            updateSelectAllState();\n        };\n\n        const updateSelectAllState = (): void => {\n            // Esta función será actualizada cuando se tengan los datos disponibles\n            selectAllChecked.set(false);\n            selectAllIndeterminate.set(false);\n        };\n\n        const toggleSelectAll = (allItems: T[]): void => {\n            const currentSelection = selectedItems();\n\n            if (currentSelection.size === allItems.length) {\n                // Desmarcar todos los elementos\n                clearSelection();\n            } else {\n                // Marcar todos los elementos\n                const allIds = new Set(allItems.map(item => item['id'] as ID));\n                selectedItems.set(allIds);\n                updateSelectAllStateWithData(allItems);\n            }\n        };\n\n        const toggleItemSelection = (item: T, multiple: boolean): void => {\n            const id = item['id'] as ID;\n            const currentSelection = new Set(selectedItems());\n\n            if (!multiple) {\n                // Selección simple: solo permitir un elemento seleccionado\n                if (currentSelection.has(id)) {\n                    // Deseleccionar el elemento actual\n                    currentSelection.clear();\n                } else {\n                    // Seleccionar solo este elemento\n                    currentSelection.clear();\n                    currentSelection.add(id);\n                }\n            } else if (currentSelection.has(id)) {\n                // Selección múltiple: deseleccionar elemento existente\n                currentSelection.delete(id);\n            } else {\n                // Selección múltiple: agregar nuevo elemento\n                currentSelection.add(id);\n            }\n\n            selectedItems.set(currentSelection);\n        };\n\n        const isItemSelected = (item: T): boolean => {\n            const id = item['id'] as ID;\n            return selectedItems().has(id);\n        };\n\n        const updateSelectAllStateWithData = (allItems: T[]): void => {\n            const selectedCount = selectedItems().size;\n            const totalCount = allItems.length;\n\n            if (selectedCount === 0) {\n                selectAllChecked.set(false);\n                selectAllIndeterminate.set(false);\n            } else if (selectedCount === totalCount) {\n                selectAllChecked.set(true);\n                selectAllIndeterminate.set(false);\n            } else {\n                selectAllChecked.set(false);\n                selectAllIndeterminate.set(true);\n            }\n        };\n\n        const preserveSelection = (newData: T[]): void => {\n            const currentSelection = selectedItems();\n\n            if (currentSelection.size === 0 || newData.length === 0) {\n                // Si no hay selección o no hay datos, limpiar la selección\n                clearSelection();\n                return;\n            }\n\n            // Obtener los IDs disponibles en los nuevos datos\n            const availableIds = new Set(newData.map(item => item['id'] as ID));\n\n            // Filtrar la selección actual para mantener solo los IDs que aún existen\n            const preservedSelection = new Set(\n                Array.from(currentSelection).filter(id => availableIds.has(id))\n            );\n\n            // Actualizar la selección con los IDs preservados\n            selectedItems.set(preservedSelection);\n            updateSelectAllStateWithData(newData);\n        };\n\n        const getSelectedItems = (allData: T[]): T[] => {\n            const selectedIds = selectedItems();\n            return allData.filter(item => selectedIds.has(item['id'] as ID));\n        };\n\n        // Redefinir updateSelectAllState con acceso a los datos\n        const originalUpdateSelectAllState = updateSelectAllState;\n        const updateSelectAllStateWrapper = (allItems?: T[]): void => {\n            if (allItems) {\n                updateSelectAllStateWithData(allItems);\n            } else {\n                originalUpdateSelectAllState();\n            }\n        };\n\n        return {\n            // Signals\n            selectedItems: selectedItems.asReadonly(),\n            selectAllChecked: selectAllChecked.asReadonly(),\n            selectAllIndeterminate: selectAllIndeterminate.asReadonly(),\n\n            // Métodos\n            clearSelection,\n            toggleSelectAll,\n            toggleItemSelection,\n            isItemSelected,\n            preserveSelection,\n            getSelectedItems,\n            updateSelectAllState: updateSelectAllStateWrapper,\n        };\n    }\n\n    /**\n     * Emite los elementos seleccionados a través del EventEmitter proporcionado\n     * @param selectionState - Estado de selección\n     * @param allData - Todos los datos de la tabla\n     * @param selectableEmitter - EventEmitter para emitir la selección\n     */\n    emitSelection<T extends Record<string, unknown>>(\n        selectionState: ReturnType<typeof this.createSelectionState<T>>,\n        allData: T[],\n        selectableEmitter: EventEmitter<T[]>\n    ): void {\n        const selectedItems = selectionState.getSelectedItems(allData);\n        selectableEmitter.emit(selectedItems);\n    }\n}\n"]}