@c80/ui 1.0.31 → 1.0.33

package/esm2022/index.mjs

@@ -1,6 +1,6 @@
 export * from './lib/table';
-export * from './lib/icon/icon.component';
-export * from './lib/stat-card/stat-card.component';
-export * from './lib/card-level/index';
-export * from './lib/modal/index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWJzL3VpL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUU1QixjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvdGFibGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pY29uL2ljb24uY29tcG9uZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvc3RhdC1jYXJkL3N0YXQtY2FyZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2FyZC1sZXZlbC9pbmRleCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGFsL2luZGV4JztcbiJdfQ==
+export * from './lib/icon';
+export * from './lib/stat-card';
+export * from './lib/card-level';
+export * from './lib/modal';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9saWJzL3VpL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi90YWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9pY29uJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N0YXQtY2FyZCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jYXJkLWxldmVsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGFsJztcbiJdfQ==

package/esm2022/lib/icon/index.mjs

@@ -0,0 +1,2 @@
+export * from './icon.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3VpL3NyYy9saWIvaWNvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pY29uLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/lib/stat-card/index.mjs

@@ -0,0 +1,2 @@
+export * from './stat-card.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3VpL3NyYy9saWIvc3RhdC1jYXJkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3N0YXQtY2FyZC5jb21wb25lbnQnO1xuIl19

package/esm2022/lib/table/index.mjs

@@ -1,2 +1,8 @@
+export * from './table.types';
 export * from './table.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3VpL3NyYy9saWIvdGFibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGFibGUuY29tcG9uZW50JztcbiJdfQ==
+export * from './table-data-converter.service';
+export * from './table-column-visibility.service';
+export * from './table-data-utils.service';
+export * from './table-selection.service';
+export * from './table-crud-state.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3VpL3NyYy9saWIvdGFibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RhYmxlLnR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUtZGF0YS1jb252ZXJ0ZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxlLWNvbHVtbi12aXNpYmlsaXR5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS1kYXRhLXV0aWxzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS1zZWxlY3Rpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxlLWNydWQtc3RhdGUuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/table/table-column-visibility.service.mjs

@@ -0,0 +1,156 @@
+import { Injectable, inject } from '@angular/core';
+import { TableDataConverterService } from './table-data-converter.service';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar la lógica de visibilidad de columnas en tablas C80
+ *
+ * Maneja las reglas complejas de visibilidad basadas en:
+ * - Configuración explícita (visible: false)
+ * - Ocultación automática (hideIfAllValuesAreNull)
+ * - Estado de creación y edición
+ */
+export class TableColumnVisibilityService {
+    dataConverter = inject(TableDataConverterService);
+    /**
+     * Actualiza las keys de columnas visibles basándose en el estado actual
+     * @param columns - Definiciones de columnas
+     * @param data - Datos actuales de la tabla
+     * @param creating - Si está en modo creación
+     * @param editing - ID de fila en edición (null si no hay edición)
+     * @returns Array de accessors de columnas visibles
+     */
+    updateVisibleKeys(columns, data, creating, editing) {
+        const visibleColumns = columns.filter(col => this.isColumnVisibleInHeader(col, data, creating, editing));
+        return visibleColumns.map(col => col.accessor);
+    }
+    /**
+     * Determina si una columna debe ser visible basándose en su configuración y datos
+     * @param column - La definición de la columna
+     * @param data - Datos actuales de la tabla
+     * @param forceShowInCreation - Si es true, ignora hideIfAllValuesAreNull (usado en modo creación)
+     * @returns true si la columna debe ser visible
+     */
+    isColumnVisible(column, data, forceShowInCreation = false) {
+        // PRIORIDAD 1: Si visible está explícitamente establecido en false, SIEMPRE ocultar
+        if (column.visible === false) {
+            return false;
+        }
+        // PRIORIDAD 2: Si hideIfAllValuesAreNull es true y todos los valores están vacíos, ocultar
+        // EXCEPCIÓN: En modo creación, mostramos estas columnas para permitir entrada de datos
+        if (column.hideIfAllValuesAreNull === true && !forceShowInCreation && this.areAllColumnValuesEmpty(column, data)) {
+            return false;
+        }
+        // Por defecto: mostrar
+        return true;
+    }
+    /**
+     * Determina si una columna debe ser visible en los headers
+     * @param column - La definición de la columna
+     * @param data - Datos actuales de la tabla
+     * @param creating - Si está en modo creación
+     * @param editing - ID de fila en edición (null si no hay edición)
+     * @returns true si el header debe ser visible
+     */
+    isColumnVisibleInHeader(column, data, creating, editing) {
+        // PRIORIDAD 1: Si visible está explícitamente establecido en false, SIEMPRE ocultar
+        if (column.visible === false) {
+            return false;
+        }
+        // Si estamos en modo creación, mostrar columnas con hideIfAllValuesAreNull
+        if (creating && column.hideIfAllValuesAreNull === true) {
+            return true;
+        }
+        // Si hay una fila en modo edición y la columna tiene hideIfAllValuesAreNull
+        if (editing !== null && column.hideIfAllValuesAreNull === true) {
+            // Buscar la fila que se está editando
+            const editingRow = data.find(row => row['id'] === editing);
+            if (editingRow) {
+                // Solo mostrar el header si la fila en edición tiene valor en esta columna
+                const cellValue = this.getCellValue(editingRow, column.accessor);
+                return !this.dataConverter.isValueEmpty(cellValue);
+            }
+            // Si no se encuentra la fila, no mostrar el header
+            return false;
+        }
+        // Si hideIfAllValuesAreNull es true y todos los valores están vacíos, ocultar
+        if (column.hideIfAllValuesAreNull === true && this.areAllColumnValuesEmpty(column, data)) {
+            return false;
+        }
+        // Por defecto: mostrar
+        return true;
+    }
+    /**
+     * Determina si una columna debe ser visible en una fila específica considerando el modo edición
+     * @param column - La definición de la columna
+     * @param row - La fila actual
+     * @param data - Datos actuales de la tabla
+     * @param editing - ID de fila en edición (null si no hay edición)
+     * @returns true si la columna debe ser visible para esta fila
+     */
+    isColumnVisibleForRow(column, row, data, editing) {
+        // PRIORIDAD 1: Si visible está explícitamente establecido en false, SIEMPRE ocultar
+        if (column.visible === false) {
+            return false;
+        }
+        // PRIORIDAD 2: Si esta fila específica está en modo edición y la columna tiene hideIfAllValuesAreNull
+        const isEditingThisRow = editing === row['id'];
+        if (isEditingThisRow && column.hideIfAllValuesAreNull === true) {
+            // En edición, solo mostrar si esta fila específica tiene valor en esta columna
+            const cellValue = this.getCellValue(row, column.accessor);
+            return !this.dataConverter.isValueEmpty(cellValue);
+        }
+        // PRIORIDAD 3: Si hideIfAllValuesAreNull es true y todos los valores están vacíos, ocultar
+        if (column.hideIfAllValuesAreNull === true && this.areAllColumnValuesEmpty(column, data)) {
+            return false;
+        }
+        // Por defecto: mostrar
+        return true;
+    }
+    /**
+     * Verifica si todos los valores de una columna están vacíos/nulos
+     * @param column - La definición de la columna
+     * @param data - Datos actuales de la tabla
+     * @returns true si todos los valores están vacíos
+     */
+    areAllColumnValuesEmpty(column, data) {
+        if (data.length === 0) {
+            return true; // Si no hay datos, consideramos la columna como vacía
+        }
+        return data.every(row => {
+            const value = this.getCellValue(row, column.accessor);
+            return this.dataConverter.isValueEmpty(value);
+        });
+    }
+    /**
+     * 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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableColumnVisibilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableColumnVisibilityService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableColumnVisibilityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-column-visibility.service.js","sourceRoot":"","sources":["../../../../../libs/ui/src/lib/table/table-column-visibility.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { C80TableColDef, ID } from './table.types';\nimport { TableDataConverterService } from './table-data-converter.service';\n\n/**\n * Servicio para gestionar la lógica de visibilidad de columnas en tablas C80\n *\n * Maneja las reglas complejas de visibilidad basadas en:\n * - Configuración explícita (visible: false)\n * - Ocultación automática (hideIfAllValuesAreNull)\n * - Estado de creación y edición\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class TableColumnVisibilityService {\n\n    private readonly dataConverter = inject(TableDataConverterService);\n\n    /**\n     * Actualiza las keys de columnas visibles basándose en el estado actual\n     * @param columns - Definiciones de columnas\n     * @param data - Datos actuales de la tabla\n     * @param creating - Si está en modo creación\n     * @param editing - ID de fila en edición (null si no hay edición)\n     * @returns Array de accessors de columnas visibles\n     */\n    updateVisibleKeys<T extends Record<string, unknown>>(\n        columns: C80TableColDef[],\n        data: T[],\n        creating: boolean,\n        editing: ID | null\n    ): string[] {\n        const visibleColumns = columns.filter(col =>\n            this.isColumnVisibleInHeader(col, data, creating, editing)\n        );\n        return visibleColumns.map(col => col.accessor);\n    }\n\n    /**\n     * Determina si una columna debe ser visible basándose en su configuración y datos\n     * @param column - La definición de la columna\n     * @param data - Datos actuales de la tabla\n     * @param forceShowInCreation - Si es true, ignora hideIfAllValuesAreNull (usado en modo creación)\n     * @returns true si la columna debe ser visible\n     */\n    isColumnVisible<T extends Record<string, unknown>>(\n        column: C80TableColDef,\n        data: T[],\n        forceShowInCreation = false\n    ): boolean {\n        // PRIORIDAD 1: Si visible está explícitamente establecido en false, SIEMPRE ocultar\n        if (column.visible === false) {\n            return false;\n        }\n\n        // PRIORIDAD 2: Si hideIfAllValuesAreNull es true y todos los valores están vacíos, ocultar\n        // EXCEPCIÓN: En modo creación, mostramos estas columnas para permitir entrada de datos\n        if (column.hideIfAllValuesAreNull === true && !forceShowInCreation && this.areAllColumnValuesEmpty(column, data)) {\n            return false;\n        }\n\n        // Por defecto: mostrar\n        return true;\n    }\n\n    /**\n     * Determina si una columna debe ser visible en los headers\n     * @param column - La definición de la columna\n     * @param data - Datos actuales de la tabla\n     * @param creating - Si está en modo creación\n     * @param editing - ID de fila en edición (null si no hay edición)\n     * @returns true si el header debe ser visible\n     */\n    isColumnVisibleInHeader<T extends Record<string, unknown>>(\n        column: C80TableColDef,\n        data: T[],\n        creating: boolean,\n        editing: ID | null\n    ): boolean {\n        // PRIORIDAD 1: Si visible está explícitamente establecido en false, SIEMPRE ocultar\n        if (column.visible === false) {\n            return false;\n        }\n\n        // Si estamos en modo creación, mostrar columnas con hideIfAllValuesAreNull\n        if (creating && column.hideIfAllValuesAreNull === true) {\n            return true;\n        }\n\n        // Si hay una fila en modo edición y la columna tiene hideIfAllValuesAreNull\n        if (editing !== null && column.hideIfAllValuesAreNull === true) {\n            // Buscar la fila que se está editando\n            const editingRow = data.find(row => row['id'] === editing);\n\n            if (editingRow) {\n                // Solo mostrar el header si la fila en edición tiene valor en esta columna\n                const cellValue = this.getCellValue(editingRow, column.accessor);\n                return !this.dataConverter.isValueEmpty(cellValue);\n            }\n\n            // Si no se encuentra la fila, no mostrar el header\n            return false;\n        }\n\n        // Si hideIfAllValuesAreNull es true y todos los valores están vacíos, ocultar\n        if (column.hideIfAllValuesAreNull === true && this.areAllColumnValuesEmpty(column, data)) {\n            return false;\n        }\n\n        // Por defecto: mostrar\n        return true;\n    }\n\n    /**\n     * Determina si una columna debe ser visible en una fila específica considerando el modo edición\n     * @param column - La definición de la columna\n     * @param row - La fila actual\n     * @param data - Datos actuales de la tabla\n     * @param editing - ID de fila en edición (null si no hay edición)\n     * @returns true si la columna debe ser visible para esta fila\n     */\n    isColumnVisibleForRow<T extends Record<string, unknown>>(\n        column: C80TableColDef,\n        row: T,\n        data: T[],\n        editing: ID | null\n    ): boolean {\n        // PRIORIDAD 1: Si visible está explícitamente establecido en false, SIEMPRE ocultar\n        if (column.visible === false) {\n            return false;\n        }\n\n        // PRIORIDAD 2: Si esta fila específica está en modo edición y la columna tiene hideIfAllValuesAreNull\n        const isEditingThisRow = editing === row['id'];\n        if (isEditingThisRow && column.hideIfAllValuesAreNull === true) {\n            // En edición, solo mostrar si esta fila específica tiene valor en esta columna\n            const cellValue = this.getCellValue(row, column.accessor);\n            return !this.dataConverter.isValueEmpty(cellValue);\n        }\n\n        // PRIORIDAD 3: Si hideIfAllValuesAreNull es true y todos los valores están vacíos, ocultar\n        if (column.hideIfAllValuesAreNull === true && this.areAllColumnValuesEmpty(column, data)) {\n            return false;\n        }\n\n        // Por defecto: mostrar\n        return true;\n    }\n\n    /**\n     * Verifica si todos los valores de una columna están vacíos/nulos\n     * @param column - La definición de la columna\n     * @param data - Datos actuales de la tabla\n     * @returns true si todos los valores están vacíos\n     */\n    areAllColumnValuesEmpty<T extends Record<string, unknown>>(\n        column: C80TableColDef,\n        data: T[]\n    ): boolean {\n        if (data.length === 0) {\n            return true; // Si no hay datos, consideramos la columna como vacía\n        }\n\n        return data.every(row => {\n            const value = this.getCellValue(row, column.accessor);\n            return this.dataConverter.isValueEmpty(value);\n        });\n    }\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    private 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    private 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"]}

package/esm2022/lib/table/table-crud-state.service.mjs

@@ -0,0 +1,165 @@
+import { Injectable, signal, inject } from '@angular/core';
+import { TableColumnVisibilityService } from './table-column-visibility.service';
+import { TableDataConverterService } from './table-data-converter.service';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar el estado CRUD (Crear, Leer, Actualizar, Eliminar) en tablas C80
+ *
+ * Maneja:
+ * - Estado de creación y edición
+ * - Gestión de datos temporales (newRow, editRow)
+ * - Aplicación de valores dinámicos
+ * - Validación y conversión de datos antes de emisión de eventos
+ */
+export class TableCrudStateService {
+    visibilityService = inject(TableColumnVisibilityService);
+    dataConverter = inject(TableDataConverterService);
+    /**
+     * Inicializa el estado CRUD para una nueva tabla
+     * @returns Objeto con signals y métodos para gestión CRUD
+     */
+    createCrudState() {
+        const creating = signal(false);
+        const newRow = signal(null);
+        const editing = signal(null);
+        const editRow = signal(null);
+        const startCreate = (columns, data) => {
+            creating.set(true);
+            // Inicializar newRow solo con columnas visibles y no readOnly
+            // En modo creación, mostramos columnas con hideIfAllValuesAreNull para permitir entrada de datos
+            const row = {};
+            columns
+                .filter((col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly)
+                .forEach((col) => {
+                // Si la columna tiene un valor por defecto, usarlo; si no, usar cadena vacía
+                const defaultValue = col.default !== undefined ? col.default : '';
+                row[col.accessor] = defaultValue;
+            });
+            newRow.set(row);
+        };
+        const cancelCreate = () => {
+            creating.set(false);
+            newRow.set(null);
+        };
+        const updateNewRow = (key, value) => {
+            const current = newRow();
+            if (!current)
+                return;
+            newRow.set({ ...current, [key]: value });
+        };
+        const saveCreate = (columns, data, createEmitter) => {
+            const row = newRow();
+            if (!row)
+                return;
+            // Validar campos requeridos antes de crear - solo columnas visibles y no readOnly
+            // En modo creación, incluimos columnas con hideIfAllValuesAreNull
+            const visibleColumns = columns.filter((col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly);
+            const converted = visibleColumns.reduce((acc, col) => {
+                const sampleValue = data.length > 0
+                    ? this.visibilityService['getCellValue'](data[0], col.accessor)
+                    : undefined;
+                acc[col.accessor] = this.dataConverter.convertCellValue(row[col.accessor], col, sampleValue);
+                return acc;
+            }, {});
+            createEmitter.emit({
+                row: converted,
+                done: (success) => {
+                    if (success) {
+                        cancelCreate();
+                    }
+                },
+            });
+        };
+        const startEdit = (row, columns, data) => {
+            editing.set(row['id']);
+            const edit = {};
+            columns
+                .filter((col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly)
+                .forEach((col) => {
+                const value = this.visibilityService['getCellValue'](row, col.accessor);
+                edit[col.accessor] = value;
+            });
+            editRow.set(edit);
+        };
+        const cancelEdit = () => {
+            editing.set(null);
+            editRow.set(null);
+        };
+        const updateEditRow = (key, value) => {
+            const current = editRow();
+            if (!current)
+                return;
+            editRow.set({ ...current, [key]: value });
+        };
+        const saveEdit = (rowId, columns, data, updateEmitter) => {
+            const currentEditRow = editRow();
+            if (!currentEditRow)
+                return;
+            const visibleColumns = columns.filter((col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly);
+            const converted = visibleColumns.reduce((acc, col) => {
+                const sampleValue = data.length > 0
+                    ? this.visibilityService['getCellValue'](data[0], col.accessor)
+                    : undefined;
+                acc[col.accessor] = this.dataConverter.convertCellValue(currentEditRow[col.accessor], col, sampleValue);
+                return acc;
+            }, {});
+            updateEmitter.emit({
+                id: rowId,
+                changes: converted,
+                done: (success) => {
+                    if (success) {
+                        cancelEdit();
+                    }
+                },
+            });
+        };
+        const applyInputValues = (partialValues) => {
+            // Solo aplicar valores si estamos en modo creación o edición
+            if (!creating() && editing() === null) {
+                return;
+            }
+            // Aplicar valores en modo creación
+            if (creating()) {
+                const currentRow = newRow();
+                if (currentRow) {
+                    const updatedRow = { ...currentRow, ...partialValues };
+                    newRow.set(updatedRow);
+                }
+            }
+            // Aplicar valores en modo edición
+            if (editing() !== null) {
+                const currentEditRow = editRow();
+                if (currentEditRow) {
+                    const updatedEditRow = { ...currentEditRow, ...partialValues };
+                    editRow.set(updatedEditRow);
+                }
+            }
+        };
+        return {
+            // Signals de solo lectura
+            creating: creating.asReadonly(),
+            newRow: newRow.asReadonly(),
+            editing: editing.asReadonly(),
+            editRow: editRow.asReadonly(),
+            // Métodos
+            startCreate,
+            cancelCreate,
+            updateNewRow,
+            saveCreate,
+            startEdit,
+            cancelEdit,
+            updateEditRow,
+            saveEdit,
+            applyInputValues,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableCrudStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableCrudStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableCrudStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-crud-state.service.js","sourceRoot":"","sources":["../../../../../libs/ui/src/lib/table/table-crud-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, EventEmitter, inject } from '@angular/core';\nimport { C80TableColDef, ID } from './table.types';\nimport { TableColumnVisibilityService } from './table-column-visibility.service';\nimport { TableDataConverterService } from './table-data-converter.service';\n\n/**\n * Servicio para gestionar el estado CRUD (Crear, Leer, Actualizar, Eliminar) en tablas C80\n *\n * Maneja:\n * - Estado de creación y edición\n * - Gestión de datos temporales (newRow, editRow)\n * - Aplicación de valores dinámicos\n * - Validación y conversión de datos antes de emisión de eventos\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class TableCrudStateService {\n\n    private readonly visibilityService = inject(TableColumnVisibilityService);\n    private readonly dataConverter = inject(TableDataConverterService);\n\n    /**\n     * Inicializa el estado CRUD para una nueva tabla\n     * @returns Objeto con signals y métodos para gestión CRUD\n     */\n    createCrudState<T extends Record<string, unknown>>() {\n        const creating = signal(false);\n        const newRow = signal<Partial<T> | null>(null);\n        const editing = signal<ID | null>(null);\n        const editRow = signal<Partial<T> | null>(null);\n\n        const startCreate = (columns: C80TableColDef[], data: T[]): void => {\n            creating.set(true);\n\n            // Inicializar newRow solo con columnas visibles y no readOnly\n            // En modo creación, mostramos columnas con hideIfAllValuesAreNull para permitir entrada de datos\n            const row: Partial<T> = {};\n            columns\n                .filter((col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly)\n                .forEach((col) => {\n                    // Si la columna tiene un valor por defecto, usarlo; si no, usar cadena vacía\n                    const defaultValue = col.default !== undefined ? col.default : '';\n                    (row as Record<string, unknown>)[col.accessor] = defaultValue;\n                });\n            newRow.set(row);\n        };\n\n        const cancelCreate = (): void => {\n            creating.set(false);\n            newRow.set(null);\n        };\n\n        const updateNewRow = (key: string, value: unknown): void => {\n            const current = newRow();\n            if (!current) return;\n            newRow.set({ ...current, [key]: value });\n        };\n\n        const saveCreate = (\n            columns: C80TableColDef[],\n            data: T[],\n            createEmitter: EventEmitter<{ row: Partial<T>; done: (result: boolean) => void; }>\n        ): void => {\n            const row = newRow();\n            if (!row) return;\n\n            // Validar campos requeridos antes de crear - solo columnas visibles y no readOnly\n            // En modo creación, incluimos columnas con hideIfAllValuesAreNull\n            const visibleColumns = columns.filter((col) =>\n                this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly\n            );\n\n            const converted = visibleColumns.reduce((acc, col) => {\n                const sampleValue = data.length > 0\n                    ? this.visibilityService['getCellValue'](data[0], col.accessor)\n                    : undefined;\n                acc[col.accessor] = this.dataConverter.convertCellValue(row[col.accessor], col, sampleValue);\n                return acc;\n            }, {} as Record<string, unknown>) as Partial<T>;\n\n            createEmitter.emit({\n                row: converted,\n                done: (success: boolean) => {\n                    if (success) {\n                        cancelCreate();\n                    }\n                },\n            });\n        };\n\n        const startEdit = (row: T, columns: C80TableColDef[], data: T[]): void => {\n            editing.set(row['id'] as ID);\n\n            const edit: Partial<T> = {};\n            columns\n                .filter((col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly)\n                .forEach((col) => {\n                    const value = this.visibilityService['getCellValue'](row, col.accessor);\n                    (edit as Record<string, unknown>)[col.accessor] = value;\n                });\n            editRow.set(edit);\n        };\n\n        const cancelEdit = (): void => {\n            editing.set(null);\n            editRow.set(null);\n        };\n\n        const updateEditRow = (key: string, value: unknown): void => {\n            const current = editRow();\n            if (!current) return;\n            editRow.set({ ...current, [key]: value });\n        };\n\n        const saveEdit = (\n            rowId: ID,\n            columns: C80TableColDef[],\n            data: T[],\n            updateEmitter: EventEmitter<{ id: ID; changes: Partial<T>; done: (result: boolean) => void; }>\n        ): void => {\n            const currentEditRow = editRow();\n            if (!currentEditRow) return;\n\n            const visibleColumns = columns.filter(\n                (col) => this.visibilityService.isColumnVisible(col, data, true) && !col.readOnly\n            );\n\n            const converted = visibleColumns.reduce((acc, col) => {\n                const sampleValue = data.length > 0\n                    ? this.visibilityService['getCellValue'](data[0], col.accessor)\n                    : undefined;\n                acc[col.accessor] = this.dataConverter.convertCellValue(\n                    currentEditRow[col.accessor],\n                    col,\n                    sampleValue\n                );\n                return acc;\n            }, {} as Record<string, unknown>) as Partial<T>;\n\n            updateEmitter.emit({\n                id: rowId,\n                changes: converted,\n                done: (success: boolean) => {\n                    if (success) {\n                        cancelEdit();\n                    }\n                },\n            });\n        };\n\n        const applyInputValues = (partialValues: Partial<T>): void => {\n            // Solo aplicar valores si estamos en modo creación o edición\n            if (!creating() && editing() === null) {\n                return;\n            }\n\n            // Aplicar valores en modo creación\n            if (creating()) {\n                const currentRow = newRow();\n                if (currentRow) {\n                    const updatedRow = { ...currentRow, ...partialValues };\n                    newRow.set(updatedRow);\n                }\n            }\n\n            // Aplicar valores en modo edición\n            if (editing() !== null) {\n                const currentEditRow = editRow();\n                if (currentEditRow) {\n                    const updatedEditRow = { ...currentEditRow, ...partialValues };\n                    editRow.set(updatedEditRow);\n                }\n            }\n        };\n\n        return {\n            // Signals de solo lectura\n            creating: creating.asReadonly(),\n            newRow: newRow.asReadonly(),\n            editing: editing.asReadonly(),\n            editRow: editRow.asReadonly(),\n\n            // Métodos\n            startCreate,\n            cancelCreate,\n            updateNewRow,\n            saveCreate,\n            startEdit,\n            cancelEdit,\n            updateEditRow,\n            saveEdit,\n            applyInputValues,\n        };\n    }\n}\n"]}

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

@@ -0,0 +1,149 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para conversión y validación de tipos de datos en tablas C80
+ *
+ * Maneja la conversión entre diferentes tipos de datos y la validación de valores vacíos.
+ * Soporta los tipos: string, number, integer, boolean, password, enum
+ */
+export class TableDataConverterService {
+    /**
+     * Convierte un valor de celda basándose en el tipo de columna o datos de muestra
+     * @param value - Valor a convertir
+     * @param col - Definición de la columna
+     * @param sampleValue - Valor de muestra para inferir el tipo (opcional)
+     * @returns Valor convertido al tipo apropiado
+     */
+    convertCellValue(value, col, sampleValue) {
+        if (col.type === 'boolean')
+            return this.toBoolean(value);
+        if (col.type === 'number')
+            return this.toNumber(value);
+        if (col.type === 'integer')
+            return this.toInteger(value);
+        if (col.type === 'string' || col.type === 'password')
+            return this.toStringValue(value);
+        // Fallback: usar datos de muestra si están disponibles
+        if (sampleValue) {
+            if (typeof sampleValue === 'boolean')
+                return this.toBoolean(value);
+            if (typeof sampleValue === 'number')
+                return this.toNumber(value);
+            if (typeof sampleValue === 'string')
+                return this.toStringValue(value);
+        }
+        return value;
+    }
+    /**
+     * Convierte un valor a boolean usando mejores prácticas
+     * @param value - Valor a convertir
+     * @returns Valor booleano
+     */
+    toBoolean(value) {
+        if (typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string')
+            return value.trim().toLowerCase() === 'true' || value.trim() === '1';
+        if (typeof value === 'number')
+            return value === 1;
+        return false;
+    }
+    /**
+     * Convierte un valor a number usando mejores prácticas
+     * @param value - Valor a convertir
+     * @returns Número o undefined si no es válido
+     */
+    toNumber(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed === '')
+                return undefined;
+            const num = Number(trimmed);
+            return isNaN(num) ? undefined : num;
+        }
+        if (typeof value === 'boolean')
+            return value ? 1 : 0;
+        return undefined;
+    }
+    /**
+     * Convierte un valor a integer usando mejores prácticas
+     * @param value - Valor a convertir
+     * @returns Entero o undefined si no es válido
+     */
+    toInteger(value) {
+        if (typeof value === 'number')
+            return Math.floor(value);
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed === '')
+                return undefined;
+            const num = Number(trimmed);
+            return isNaN(num) ? undefined : Math.floor(num);
+        }
+        if (typeof value === 'boolean')
+            return value ? 1 : 0;
+        return undefined;
+    }
+    /**
+     * Convierte un valor a string usando mejores prácticas, siempre stringifica objetos
+     * @param value - Valor a convertir
+     * @returns Cadena de texto
+     */
+    toStringValue(value) {
+        if (value == null)
+            return '';
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return '[object Object]';
+            }
+        }
+        // Para funciones, símbolos, undefined, etc., devolver cadena vacía
+        return '';
+    }
+    /**
+     * Verifica si un valor individual está vacío/nulo
+     * @param value - Valor a verificar
+     * @returns true si el valor se considera vacío
+     */
+    isValueEmpty(value) {
+        // Considerar vacío: null, undefined, ''
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        // Para números, 0 se considera como valor válido, no vacío
+        if (typeof value === 'number') {
+            return false;
+        }
+        // Para booleanos, false se considera como valor válido, no vacío
+        if (typeof value === 'boolean') {
+            return false;
+        }
+        // Para arrays vacíos
+        if (Array.isArray(value) && value.length === 0) {
+            return true;
+        }
+        // Para objetos vacíos
+        if (typeof value === 'object' && value !== null && Object.keys(value).length === 0) {
+            return true;
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableDataConverterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableDataConverterService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TableDataConverterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-data-converter.service.js","sourceRoot":"","sources":["../../../../../libs/ui/src/lib/table/table-data-converter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { C80TableColDef } from './table.types';\n\n/**\n * Servicio para conversión y validación de tipos de datos en tablas C80\n *\n * Maneja la conversión entre diferentes tipos de datos y la validación de valores vacíos.\n * Soporta los tipos: string, number, integer, boolean, password, enum\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class TableDataConverterService {\n\n    /**\n     * Convierte un valor de celda basándose en el tipo de columna o datos de muestra\n     * @param value - Valor a convertir\n     * @param col - Definición de la columna\n     * @param sampleValue - Valor de muestra para inferir el tipo (opcional)\n     * @returns Valor convertido al tipo apropiado\n     */\n    convertCellValue(value: unknown, col: C80TableColDef, sampleValue?: unknown): unknown {\n        if (col.type === 'boolean') return this.toBoolean(value);\n        if (col.type === 'number') return this.toNumber(value);\n        if (col.type === 'integer') return this.toInteger(value);\n        if (col.type === 'string' || col.type === 'password')\n            return this.toStringValue(value);\n\n        // Fallback: usar datos de muestra si están disponibles\n        if (sampleValue) {\n            if (typeof sampleValue === 'boolean') return this.toBoolean(value);\n            if (typeof sampleValue === 'number') return this.toNumber(value);\n            if (typeof sampleValue === 'string') return this.toStringValue(value);\n        }\n\n        return value;\n    }\n\n    /**\n     * Convierte un valor a boolean usando mejores prácticas\n     * @param value - Valor a convertir\n     * @returns Valor booleano\n     */\n    toBoolean(value: unknown): boolean {\n        if (typeof value === 'boolean') return value;\n        if (typeof value === 'string')\n            return value.trim().toLowerCase() === 'true' || value.trim() === '1';\n        if (typeof value === 'number') return value === 1;\n        return false;\n    }\n\n    /**\n     * Convierte un valor a number usando mejores prácticas\n     * @param value - Valor a convertir\n     * @returns Número o undefined si no es válido\n     */\n    toNumber(value: unknown): number | undefined {\n        if (typeof value === 'number') return value;\n        if (typeof value === 'string') {\n            const trimmed = value.trim();\n            if (trimmed === '') return undefined;\n            const num = Number(trimmed);\n            return isNaN(num) ? undefined : num;\n        }\n        if (typeof value === 'boolean') return value ? 1 : 0;\n        return undefined;\n    }\n\n    /**\n     * Convierte un valor a integer usando mejores prácticas\n     * @param value - Valor a convertir\n     * @returns Entero o undefined si no es válido\n     */\n    toInteger(value: unknown): number | undefined {\n        if (typeof value === 'number') return Math.floor(value);\n        if (typeof value === 'string') {\n            const trimmed = value.trim();\n            if (trimmed === '') return undefined;\n            const num = Number(trimmed);\n            return isNaN(num) ? undefined : Math.floor(num);\n        }\n        if (typeof value === 'boolean') return value ? 1 : 0;\n        return undefined;\n    }\n\n    /**\n     * Convierte un valor a string usando mejores prácticas, siempre stringifica objetos\n     * @param value - Valor a convertir\n     * @returns Cadena de texto\n     */\n    toStringValue(value: unknown): string {\n        if (value == null) return '';\n        if (typeof value === 'string') return value;\n        if (typeof value === 'number' || typeof value === 'boolean')\n            return String(value);\n        if (typeof value === 'object') {\n            try {\n                return JSON.stringify(value);\n            } catch {\n                return '[object Object]';\n            }\n        }\n        // Para funciones, símbolos, undefined, etc., devolver cadena vacía\n        return '';\n    }\n\n    /**\n     * Verifica si un valor individual está vacío/nulo\n     * @param value - Valor a verificar\n     * @returns true si el valor se considera vacío\n     */\n    isValueEmpty(value: unknown): boolean {\n        // Considerar vacío: null, undefined, ''\n        if (value === null || value === undefined || value === '') {\n            return true;\n        }\n\n        // Para números, 0 se considera como valor válido, no vacío\n        if (typeof value === 'number') {\n            return false;\n        }\n\n        // Para booleanos, false se considera como valor válido, no vacío\n        if (typeof value === 'boolean') {\n            return false;\n        }\n\n        // Para arrays vacíos\n        if (Array.isArray(value) && value.length === 0) {\n            return true;\n        }\n\n        // Para objetos vacíos\n        if (typeof value === 'object' && value !== null && Object.keys(value).length === 0) {\n            return true;\n        }\n\n        return false;\n    }\n}\n"]}