@c80/ui 1.0.32 → 1.0.33

package/esm2022/lib/table/table.types.mjs

@@ -0,0 +1,5 @@
+/**
+ * Tipos comunes para las tablas C80
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3VpL3NyYy9saWIvdGFibGUvdGFibGUudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRpcG9zIGNvbXVuZXMgcGFyYSBsYXMgdGFibGFzIEM4MFxuICovXG5cbmV4cG9ydCB0eXBlIElEID0gbnVtYmVyIHwgc3RyaW5nO1xuXG5leHBvcnQgaW50ZXJmYWNlIEM4MFRhYmxlQ29sRGVmIHtcbiAgICBhY2Nlc3Nvcjogc3RyaW5nO1xuICAgIGxhYmVsOiBzdHJpbmc7XG4gICAgdmlzaWJsZT86IGJvb2xlYW47IC8vIFNpIG5vIHNlIGVzcGVjaWZpY2EsIHNlIGFzdW1lIHRydWUuIFNpIGVzIGZhbHNlLCBsYSBjb2x1bW5hIHNlIG9jdWx0YSBTSUVNUFJFIChtw6F4aW1hIHByaW9yaWRhZClcbiAgICB0eXBlPzogJ3N0cmluZycgfCAnbnVtYmVyJyB8ICdpbnRlZ2VyJyB8ICdib29sZWFuJyB8ICdwYXNzd29yZCcgfCAnZW51bSc7IC8vIFRpcG8gZGUgZGF0byBwYXJhIGxhIGNvbHVtbmFcbiAgICBvcmRlcj86ICdBU0MnIHwgJ0RFU0MnOyAvLyBPcmRlbmFtaWVudG8gZGUgbGEgY29sdW1uYVxuICAgIHJlYWRPbmx5PzogYm9vbGVhbjsgLy8gU2kgbm8gc2UgZXNwZWNpZmljYSwgc2UgYXN1bWUgZmFsc2VcbiAgICBlbnVtPzogUmVjb3JkPHN0cmluZyB8IG51bWJlciwgc3RyaW5nPjsgLy8gT3BjaW9uZXMgZGVsIGVudW0gcGFyYSB0eXBlICdlbnVtJ1xuICAgIGNvbG9yPzogUmVjb3JkPHN0cmluZyB8IG51bWJlciwgc3RyaW5nPjsgLy8gQ29sb3JlcyBDU1MgYmFzYWRvcyBlbiBlbCB2YWxvciBkZSBsYSBjZWxkYVxuICAgIGhpZGVJZkFsbFZhbHVlc0FyZU51bGw/OiBib29sZWFuOyAvLyBTaSBlcyB0cnVlLCBvY3VsdGEgbGEgY29sdW1uYSBjdWFuZG8gdG9kb3MgbG9zIHZhbG9yZXMgZXN0w6FuIHZhY8Otb3MgKGRlZmF1bHQ6IGZhbHNlKS5cbiAgICAvLyBTb2xvIGFwbGljYSBzaSB2aXNpYmxlICE9PSBmYWxzZS4gRVhDRVBDScOTTjogRW4gbW9kbyBjcmVhY2nDs24gWSBlZGljacOzbiBzaWVtcHJlIHNlIG11ZXN0cmEuXG4gICAgZGVmYXVsdD86IHVua25vd247IC8vIFZhbG9yIHBvciBkZWZlY3RvIHBhcmEgdXNhciBlbiBtb2RvIGNyZWFjacOzbi4gUHVlZGUgc2VyIHN0cmluZywgbnVtYmVyLCBib29sZWFuLCBldGMuXG59XG4iXX0=

package/lib/table/index.d.ts

@@ -1 +1,7 @@
+export * from './table.types';
 export * from './table.component';
+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';

package/lib/table/table-column-visibility.service.d.ts

@@ -0,0 +1,71 @@
+import { C80TableColDef, ID } from './table.types';
+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 declare class TableColumnVisibilityService {
+    private readonly dataConverter;
+    /**
+     * 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<T extends Record<string, unknown>>(columns: C80TableColDef[], data: T[], creating: boolean, editing: ID | null): string[];
+    /**
+     * 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<T extends Record<string, unknown>>(column: C80TableColDef, data: T[], forceShowInCreation?: boolean): boolean;
+    /**
+     * 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<T extends Record<string, unknown>>(column: C80TableColDef, data: T[], creating: boolean, editing: ID | null): boolean;
+    /**
+     * 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<T extends Record<string, unknown>>(column: C80TableColDef, row: T, data: T[], editing: ID | null): boolean;
+    /**
+     * 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<T extends Record<string, unknown>>(column: C80TableColDef, data: T[]): boolean;
+    /**
+     * 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
+     */
+    private getCellValue;
+    /**
+     * 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
+     */
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnVisibilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableColumnVisibilityService>;
+}

package/lib/table/table-crud-state.service.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from '@angular/core';
+import { C80TableColDef, ID } from './table.types';
+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 declare class TableCrudStateService {
+    private readonly visibilityService;
+    private readonly dataConverter;
+    /**
+     * Inicializa el estado CRUD para una nueva tabla
+     * @returns Objeto con signals y métodos para gestión CRUD
+     */
+    createCrudState<T extends Record<string, unknown>>(): {
+        creating: import("@angular/core").Signal<boolean>;
+        newRow: import("@angular/core").Signal<Partial<T> | null>;
+        editing: import("@angular/core").Signal<ID | null>;
+        editRow: import("@angular/core").Signal<Partial<T> | null>;
+        startCreate: (columns: C80TableColDef[], data: T[]) => void;
+        cancelCreate: () => void;
+        updateNewRow: (key: string, value: unknown) => void;
+        saveCreate: (columns: C80TableColDef[], data: T[], createEmitter: EventEmitter<{
+            row: Partial<T>;
+            done: (result: boolean) => void;
+        }>) => void;
+        startEdit: (row: T, columns: C80TableColDef[], data: T[]) => void;
+        cancelEdit: () => void;
+        updateEditRow: (key: string, value: unknown) => void;
+        saveEdit: (rowId: ID, columns: C80TableColDef[], data: T[], updateEmitter: EventEmitter<{
+            id: ID;
+            changes: Partial<T>;
+            done: (result: boolean) => void;
+        }>) => void;
+        applyInputValues: (partialValues: Partial<T>) => void;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCrudStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableCrudStateService>;
+}

package/lib/table/table-data-converter.service.d.ts

@@ -0,0 +1,50 @@
+import { C80TableColDef } from './table.types';
+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 declare 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: unknown, col: C80TableColDef, sampleValue?: unknown): unknown;
+    /**
+     * Convierte un valor a boolean usando mejores prácticas
+     * @param value - Valor a convertir
+     * @returns Valor booleano
+     */
+    toBoolean(value: unknown): boolean;
+    /**
+     * 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: unknown): number | 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: unknown): number | undefined;
+    /**
+     * Convierte un valor a string usando mejores prácticas, siempre stringifica objetos
+     * @param value - Valor a convertir
+     * @returns Cadena de texto
+     */
+    toStringValue(value: unknown): string;
+    /**
+     * 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: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDataConverterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableDataConverterService>;
+}

package/lib/table/table-data-utils.service.d.ts

@@ -0,0 +1,70 @@
+import { C80TableColDef } from './table.types';
+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 declare 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<T extends Record<string, unknown>>(row: T, accessor: string): unknown;
+    /**
+     * 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: any, accessor: string): unknown;
+    /**
+     * 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: unknown): string;
+    /**
+     * 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: unknown, col: C80TableColDef): string;
+    /**
+     * 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: C80TableColDef): {
+        value: string | number;
+        label: string;
+    }[];
+    /**
+     * 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: unknown, col: C80TableColDef): string | undefined;
+    /**
+     * 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<T extends Record<string, unknown>>(items: T[], columns: C80TableColDef[]): void;
+    /**
+     * 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: number): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDataUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableDataUtilsService>;
+}

package/lib/table/table-selection.service.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from '@angular/core';
+import { ID } from './table.types';
+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 declare class TableSelectionService {
+    /**
+     * Inicializa el estado de selección para una nueva tabla
+     * @returns Objeto con signals y métodos de selección
+     */
+    createSelectionState<T extends Record<string, unknown>>(): {
+        selectedItems: import("@angular/core").Signal<Set<ID>>;
+        selectAllChecked: import("@angular/core").Signal<boolean>;
+        selectAllIndeterminate: import("@angular/core").Signal<boolean>;
+        clearSelection: () => void;
+        toggleSelectAll: (allItems: T[]) => void;
+        toggleItemSelection: (item: T, multiple: boolean) => void;
+        isItemSelected: (item: T) => boolean;
+        preserveSelection: (newData: T[]) => void;
+        getSelectedItems: (allData: T[]) => T[];
+        updateSelectAllState: (allItems?: T[]) => void;
+    };
+    /**
+     * 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<T extends Record<string, unknown>>(selectionState: ReturnType<typeof this.createSelectionState<T>>, allData: T[], selectableEmitter: EventEmitter<T[]>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableSelectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableSelectionService>;
+}

package/lib/table/table.component.d.ts

@@ -1,19 +1,7 @@
 import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
 import { Observable } from 'rxjs';
+import { C80TableColDef, ID } from './table.types';
 import * as i0 from "@angular/core";
-export interface C80TableColDef {
-    accessor: string;
-    label: string;
-    visible?: boolean;
-    type?: 'string' | 'number' | 'integer' | 'boolean' | 'password' | 'enum';
-    order?: 'ASC' | 'DESC';
-    readOnly?: boolean;
-    enum?: Record<string | number, string>;
-    color?: Record<string | number, string>;
-    hideIfAllValuesAreNull?: boolean;
-    default?: unknown;
-}
-export type ID = number | string;
 /**
  * C80TableComponent - Componente de tabla avanzado con funcionalidades CRUD
  *
@@ -71,6 +59,10 @@ export type ID = number | string;
  * - inputValues$ emite { motorPos: 5, weight: 2.3 } → actualiza inputs dinámicamente
  */ export declare class C80TableComponent<T extends Record<string, unknown>> implements OnInit, OnDestroy {
     private readonly modalService;
+    private readonly visibilityService;
+    private readonly dataUtils;
+    private readonly selectionService;
+    private readonly crudService;
     data$: Observable<T[]>;
     columns: C80TableColDef[];
     inputValues$?: Observable<Partial<T>>;
@@ -115,14 +107,16 @@ export type ID = number | string;
     selectable: EventEmitter<T[]>;
     readonly data: import("@angular/core").WritableSignal<T[]>;
     readonly keys: import("@angular/core").WritableSignal<string[]>;
-    creating: import("@angular/core").WritableSignal<boolean>;
-    newRow: import("@angular/core").WritableSignal<Partial<T> | null>;
-    readonly editing: import("@angular/core").WritableSignal<ID | null>;
-    readonly editRow: import("@angular/core").WritableSignal<Partial<T> | null>;
-    readonly selectedItems: import("@angular/core").WritableSignal<Set<ID>>;
-    readonly selectAllChecked: import("@angular/core").WritableSignal<boolean>;
-    readonly selectAllIndeterminate: import("@angular/core").WritableSignal<boolean>;
     readonly searchValue: import("@angular/core").WritableSignal<string>;
+    private readonly selectionState;
+    readonly selectedItems: import("@angular/core").Signal<Set<ID>>;
+    readonly selectAllChecked: import("@angular/core").Signal<boolean>;
+    readonly selectAllIndeterminate: import("@angular/core").Signal<boolean>;
+    private readonly crudState;
+    readonly creating: import("@angular/core").Signal<boolean>;
+    readonly newRow: import("@angular/core").Signal<Partial<T> | null>;
+    readonly editing: import("@angular/core").Signal<ID | null>;
+    readonly editRow: import("@angular/core").Signal<Partial<T> | null>;
     readonly hasCreateActionListener: import("@angular/core").WritableSignal<boolean>;
     readonly hasUpdateActionListener: import("@angular/core").WritableSignal<boolean>;
     readonly hasDeleteActionListener: import("@angular/core").WritableSignal<boolean>;
@@ -156,23 +150,6 @@ export type ID = number | string;
     cancelCreate(): void;
     updateNewRow(key: string, value: unknown): void;
     saveCreate(): void;
-    /**
-     * Converts a cell value based on column type or sample data.
-     * Handles stringification of objects for string columns.
-     */
-    /**
-     * Converts a cell value based on column type or sample data.
-     * Delegates to type-specific helpers for clarity and maintainability.
-     */
-    private convertCellValue;
-    /** Converts value to boolean using best practices. */
-    private toBoolean;
-    /** Converts value to number using best practices. */
-    private toNumber;
-    /** Converts value to integer using best practices. */
-    private toInteger;
-    /** Converts value to string using best practices, always stringifies objects. */
-    private toStringValue;
     onEdit(row: T): void;
     cancelEdit(): void;
     onEditInput(event: Event, key: string, col?: C80TableColDef): void;
@@ -209,37 +186,14 @@ export type ID = number | string;
      * Clears the search input
      */
     clearSearch(): void;
-    /**
-     * Gets the value from an object using dot notation (e.g., 'task.name')
-     */
-    private getNestedValue;
-    /**
-     * Gets the value for a cell using the accessor, supporting dot notation for nested properties
-     */
     getCellValue(row: T, accessor: string): unknown;
-    /**
-     * Returns the display value for a cell, showing '-' for falsy values except 0, false, and empty objects/arrays
-     */
     getDisplayValue(value: unknown): string;
-    /**
-     * Gets the display text for an enum value
-     */
     getEnumDisplayValue(value: unknown, col: C80TableColDef): string;
-    /**
-     * Gets the enum options as an array for select dropdowns
-     */
     getEnumOptions(col: C80TableColDef): {
         value: string | number;
         label: string;
     }[];
-    /**
-     * Gets the CSS color for a cell value based on the column's color configuration
-     */
     getCellColor(value: unknown, col: C80TableColDef): string | undefined;
-    /**
-     * Calcula el max-height de la tabla basado en el tamaño
-     * Si size es 0, retorna undefined (sin límite de altura)
-     */
     getTableMaxHeight(): string | undefined;
     /**
      * Selection methods
@@ -253,48 +207,9 @@ export type ID = number | string;
     toggleSelectAll(): void;
     toggleItemSelection(item: T): void;
     isItemSelected(item: T): boolean;
-    private updateSelectAllState;
-    private emitSelection;
-    /**
-     * Verifica si un valor individual está vacío/nulo
-     */
-    private isValueEmpty;
-    /**
-     * Verifica si todos los valores de una columna están vacíos/nulos
-     */
-    private areAllColumnValuesEmpty;
-    /**
-     * Determina si una columna debe ser visible basándose en su configuración y datos.
-     *
-     * Orden de prioridad:
-     * 1. Si visible === false: SIEMPRE se oculta (máxima prioridad)
-     * 2. Si hideIfAllValuesAreNull === true Y todos los valores están vacíos: se oculta
-     *    EXCEPCIÓN: En modo creación (creating === true), estas columnas se muestran para permitir entrada de datos
-     * 3. Por defecto: se muestra
-     *
-     * @param column - La definición de la columna
-     * @param forceShowInCreation - Si es true, ignora hideIfAllValuesAreNull (usado en modo creación)
-     */
     isColumnVisible(column: C80TableColDef, forceShowInCreation?: boolean): boolean;
-    /**
-     * Determina si una columna debe ser visible en los headers.
-     * Los headers se muestran si la columna es visible en cualquiera de estos casos:
-     * - Visualización normal
-     * - Modo creación
-     * - Hay una fila en modo edición y esa fila tiene valor en la columna
-     *
-     * @param column - La definición de la columna
-     */
     isColumnVisibleInHeader(column: C80TableColDef): boolean;
-    /**
-     * Determina si una columna debe ser visible en una fila específica considerando el modo edición.
-     * En modo edición, las columnas con hideIfAllValuesAreNull se muestran solo si tienen valor.
-     *
-     * @param column - La definición de la columna
-     * @param row - La fila actual
-     */
     isColumnVisibleForRow(column: C80TableColDef, row: T): boolean;
-    private applySorting;
     onUpload(row: T): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<C80TableComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<C80TableComponent<any>, "c80-table", never, { "data$": { "alias": "data$"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "inputValues$": { "alias": "inputValues$"; "required": false; }; "size": { "alias": "size"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "noConfirm": { "alias": "noConfirm"; "required": false; }; }, { "createAction": "createAction"; "updateAction": "updateAction"; "deleteAction": "deleteAction"; "cancelAction": "cancelAction"; "viewAction": "viewAction"; "uploadAction": "uploadAction"; "getRowButtonAction": "getRowButtonAction"; "moveUpAction": "moveUpAction"; "moveDownAction": "moveDownAction"; "enableAction": "enableAction"; "searchTerm": "searchTerm"; "errorEvent": "errorEvent"; "selectable": "selectable"; }, never, never, true, never>;

package/lib/table/table.types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tipos comunes para las tablas C80
+ */
+export type ID = number | string;
+export interface C80TableColDef {
+    accessor: string;
+    label: string;
+    visible?: boolean;
+    type?: 'string' | 'number' | 'integer' | 'boolean' | 'password' | 'enum';
+    order?: 'ASC' | 'DESC';
+    readOnly?: boolean;
+    enum?: Record<string | number, string>;
+    color?: Record<string | number, string>;
+    hideIfAllValuesAreNull?: boolean;
+    default?: unknown;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c80/ui",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "peerDependencies": {
     "@angular/core": "^18.2.0",
     "rxjs": "~7.8.0",