@envisiongroup/porygon 1.0.0-rc.9 → 1.0.0

package/dist/react-components/tables/EFWTable/EFWTable.types.d.ts

@@ -1,10 +1,38 @@
-import { ListChildComponentProps } from 'react-window';
-import { TableRowData, CardProps } from '@fluentui/react-components';
-import { DefaultDrawerButtonProps, EFWTableCommandBarButton } from './components/EFWTableCommandBar/EFWTableCommandBar.types';
+import { RowData } from '@tanstack/react-table';
+import { CardProps } from '@fluentui/react-components';
+import { DefaultDrawerButtonProps, DefaultFilterButtonProps, EFWTableCommandBarButton } from './components/EFWTableCommandBar/EFWTableCommandBar.types';
 import { EFWFormFieldProps, EFWFormFieldType, EFWFormFieldValue } from '../../forms/EFWForm';
 import { ExtractFieldNames, GetFieldValue } from '../../forms/EFWForm/EFWForm.types';
 import { EFWTableOverlayConfig, EFWTableOverlayState, EFWTableOverlayCustomization, EFWTableLoadingOptions, EFWTableErrorOptions, EFWTablePartialLoadingOptions, EFWTableEmptyOptions } from './components/EFWTableOverlay';
+import { EFWTableExtendedLocaleText } from '../../i18n';
 
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        typeAsString?: string;
+        cellLineClamp?: number;
+    }
+}
+/**
+ * Tipo para los valores de filtro activos en la tabla.
+ * Las claves son los `internalName` de los campos y los valores son los valores de filtro.
+ */
+export type FilterValues<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> = string extends ExtractFieldNames<T> ? Record<string, EFWFormFieldValue | null | undefined> : Partial<{
+    [K in ExtractFieldNames<T>]: GetFieldValue<T, K> | null | undefined;
+}>;
+/**
+ * Descriptor público de ordenamiento de EFWTable.
+ * - `id`: internalName de la columna
+ * - `desc`: true = descendente, false = ascendente
+ */
+export interface EFWTableSort {
+    id: string;
+    desc: boolean;
+}
+/**
+ * Estado público de ordenamiento de EFWTable.
+ * Se mantiene desacoplado de tipos internos de TanStack.
+ */
+export type EFWTableSortingState = EFWTableSort[];
 /**
  * Tipo base para los elementos de la tabla (fallback genérico con index signature).
  * Se usa internamente cuando no hay tipado específico disponible.
@@ -38,24 +66,26 @@ export type EFWTableItem<T extends readonly EFWFormFieldProps[] = EFWFormFieldPr
 } & {
     _rowId?: string;
 };
-/**
- * Tipo para items de entrada (sin _rowId) - lo que el usuario proporciona.
- * Útil para firmas de métodos como addItem/addItems donde el _rowId se genera internamente.
- */
-export type EFWTableItemInput<T extends readonly EFWFormFieldProps[]> = string extends ExtractFieldNames<T> ? Omit<EFWTableItemBase, '_rowId'> : {
-    [K in ExtractFieldNames<T>]: GetFieldValue<T, K>;
-};
-/**
- * Tipo para items con _rowId garantizado (uso interno).
- * Representa un item que ya fue procesado y tiene un identificador único.
- */
-export type EFWTableItemComplete<T extends readonly EFWFormFieldProps[]> = EFWTableItemInput<T> & {
-    readonly _rowId: string;
-};
 export interface EFWTableRow<T = EFWTableItem> {
     index: number;
     item: T;
 }
+export type EFWTableInsertPosition = 'start' | 'end';
+export interface EFWTableRowAnimationOptions {
+    animateRows?: boolean;
+}
+export interface EFWTableRowAnimationConfig {
+    addRows?: boolean;
+    updateRows?: boolean;
+}
+export interface EFWTableAddOptions extends EFWTableRowAnimationOptions {
+    position?: EFWTableInsertPosition;
+}
+export type EFWTableUpdateOptions = EFWTableRowAnimationOptions;
+export interface EFWTableRowAnimationSignal {
+    delay: number;
+    token: number;
+}
 export interface OperationResult<T> {
     successful: {
         index: number;
@@ -67,19 +97,53 @@ export interface OperationResult<T> {
         error?: string | Error;
     }[];
 }
+/**
+ * Resultado flexible para el callback beforeUpdateItems.
+ *
+ * Permite reportar éxito solo con `index` y delegar al componente
+ * la reconstrucción del item completo antes de notificar/retornar.
+ */
+export interface BeforeUpdateItemsResult<T> {
+    successful: {
+        index: number;
+        item?: Partial<T>;
+    }[];
+    failed: {
+        index: number;
+        item?: Partial<T>;
+        error?: string | Error;
+    }[];
+}
+/**
+ * Resultado flexible para el callback beforeDeleteItems.
+ *
+ * Permite reportar éxito solo con `index` y delegar al componente
+ * la reconstrucción del item completo antes de notificar/retornar.
+ */
+export interface BeforeDeleteItemsResult<T> {
+    successful: {
+        index: number;
+        item?: Partial<T>;
+    }[];
+    failed: {
+        index: number;
+        item?: Partial<T>;
+        error?: string | Error;
+    }[];
+}
 /**
  * Interfaz que define los métodos expuestos por el componente EFWForm para controlar su estado y comportamiento.
  * Estos métodos permiten interactuar con los valores, estado de edición, validaciones y mensajes del formulario.
  */
 export interface EFWTableMethods<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> {
     getFields: () => T;
-    addItem: (item: Omit<EFWTableItem<T>, '_rowId'>) => Promise<OperationResult<EFWTableItem<T>>>;
-    addItems: (items: Omit<EFWTableItem<T>, '_rowId'>[]) => Promise<OperationResult<EFWTableItem<T>>>;
-    updateItem: (index: number, item: Partial<EFWTableItem<T>>) => Promise<OperationResult<EFWTableItem<T>>>;
+    addItem: (item: Omit<EFWTableItem<T>, '_rowId'>, options?: EFWTableAddOptions) => Promise<OperationResult<EFWTableItem<T>>>;
+    addItems: (items: Omit<EFWTableItem<T>, '_rowId'>[], options?: EFWTableAddOptions) => Promise<OperationResult<EFWTableItem<T>>>;
+    updateItem: (index: number, item: Partial<EFWTableItem<T>>, options?: EFWTableUpdateOptions) => Promise<OperationResult<EFWTableItem<T>>>;
     updateItems: (items: {
         index: number;
         item: Partial<EFWTableItem<T>>;
-    }[]) => Promise<OperationResult<EFWTableItem<T>>>;
+    }[], options?: EFWTableUpdateOptions) => Promise<OperationResult<EFWTableItem<T>>>;
     deleteItem: (index: number) => Promise<OperationResult<EFWTableItem<T>>>;
     deleteItems: (indexes: number[]) => Promise<OperationResult<EFWTableItem<T>>>;
     getItem: (id: string | number) => EFWTableItem<T> | undefined;
@@ -128,42 +192,74 @@ export interface EFWTableMethods<T extends readonly EFWFormFieldProps[] = EFWFor
      * Retorna el estado actual del overlay
      */
     getOverlayState: () => EFWTableOverlayState;
+    /**
+     * Retorna los campos de la tabla que tienen el filtrado habilitado.
+     * Por defecto todas las columnas son filtrables, excepto:
+     * - las que tengan `filterable: false` en `columnConfig`
+     * - los campos de tipo `Attachments` (siempre excluidos del drawer de filtros)
+     */
+    getFilterableFields: () => Exclude<T[number], EFWFormFieldProps<'Attachments'>>[];
+    /**
+     * Retorna los valores de filtro activos actualmente.
+     */
+    getColumnFilters: () => FilterValues<T>;
+    /**
+     * Indica si hay al menos un filtro activo en la tabla.
+     */
+    hasActiveFilters: () => boolean;
+    /**
+     * Establece los valores de filtro de la tabla.
+     * @param filters - Mapa de `{ [internalName]: filterValue }`
+     */
+    setColumnFilters: (filters: FilterValues<T>) => void;
+    /**
+     * Elimina todos los filtros activos de la tabla.
+     */
+    clearColumnFilters: () => void;
+    /**
+     * Retorna el estado de ordenamiento activo.
+     */
+    getSortingState: () => EFWTableSortingState;
+    /**
+     * Retorna la columna de ordenamiento primaria activa o null si no hay sorting.
+     */
+    getPrimarySortedColumn: () => EFWTableSort | null;
+    /**
+     * Indica si hay al menos una columna ordenada.
+     */
+    hasActiveSorting: () => boolean;
+    /**
+     * Establece el estado de ordenamiento de la tabla.
+     * @param sortingState - Lista de columnas ordenadas por prioridad.
+     */
+    setSortingState: (sortingState: EFWTableSortingState) => void;
+    /**
+     * Elimina todo el ordenamiento activo.
+     */
+    clearSorting: () => void;
 }
 /**
  * Tipo que representa la referencia al componente EFWForm.
  * Puede ser un objeto con los métodos de `EFWFormMethods` o null si no está inicializado.
  */
 export type EFWTableRef<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> = EFWTableMethods<T> | null;
-export interface EFWTableButton {
-    key: string;
-    label?: string | (() => string);
-    icon?: React.ReactNode | (() => React.ReactNode);
-    appearance?: "primary" | "outline" | "subtle" | "secondary" | "transparent";
-    disabled?: boolean | ((selectedItems: EFWTableItem[], selectedIndexes: number[]) => boolean);
-    hidden?: boolean;
-    title?: string | (() => string);
-    loading?: boolean | (() => boolean);
-    className?: string;
-    onClick?: (e: React.MouseEvent) => void;
-    render?: (config: EFWTableButton, selectedItems: EFWTableItem[], selectedIndexes: number[]) => React.ReactNode;
-}
-export interface EFWTableRowData extends TableRowData<EFWTableItem> {
-    onClick: (e: React.MouseEvent) => void;
-    onKeyDown: (e: React.KeyboardEvent) => void;
-    onCheckboxClick: (e: React.MouseEvent) => void;
-    selected: boolean;
-    appearance: "brand" | "none" | "neutral";
-}
-export interface ReactWindowRenderFnProps extends ListChildComponentProps {
-    data: EFWTableRowData[];
-    fields: EFWFormFieldProps[];
-    columnSizing?: any;
-    resizableColumns: boolean;
-    customGetFieldIcon?: (internalName: string, item: EFWTableItem) => React.ReactNode;
-}
+export type EFWTableCommandBarButtonInput<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> = EFWTableCommandBarButton<T> | EFWTableCommandBarButton;
 export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormFieldProps[]> {
     appearance?: CardProps['appearance'];
     fields: T;
+    /**
+     * Textos de localización para labels internos de tabla.
+     * Si se omite, se usan los defaults del provider global (o defaults internos en español).
+     */
+    /**
+     * Textos de localización para labels internos de tabla.
+     * Si se omite, se usan los defaults del provider global (o defaults internos en español).
+     *
+     * Opcionalmente puede incluir `form`, `fields` y `buttons` para traducir
+     * los formularios, campos y botones dentro de los drawers CRUD de la tabla,
+     * sin necesidad de un `PorygonI18nProvider` externo.
+     */
+    localeText?: Partial<EFWTableExtendedLocaleText>;
     /**
      * Items de la tabla en modo CONTROLLED.
      * Cuando se proporciona `items`, el componente NO maneja el estado internamente.
@@ -194,6 +290,19 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
      */
     height?: number;
     itemSize?: number;
+    dense?: boolean;
+    /**
+     * Configuración default para animar filas actualizadas mediante métodos de la tabla.
+     *
+     * La opción por llamada (`addItem(..., { animateRows })`) tiene prioridad sobre
+     * esta configuración global.
+     */
+    rowAnimationConfig?: EFWTableRowAnimationConfig;
+    /**
+     * Número máximo de líneas visibles en celdas de tipo Text, Note, Choice, MultiChoice y Attachments.
+     * Se puede sobrescribir por columna usando `columnConfig[col].cellLineClamp`.
+     */
+    cellLineClamp?: number;
     enableSelection?: boolean;
     enableCommandBar?: boolean;
     tableStyle?: 'row' | 'grid';
@@ -202,33 +311,121 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
     defaultSelectedItems?: Set<number>;
     onSelectionChange?: (selectedItems: Set<number>) => void;
     onRowClick?: (item: EFWTableItem<T>, index: number) => void;
+    onRowDoubleClick?: (item: EFWTableItem<T>, index: number) => void;
     resizableColumns?: boolean;
     autoSizeColumns?: boolean;
-    columnSizing?: Record<string, {
+    columnConfig?: Record<string, {
         maxWidth?: number;
         width?: number;
         minWidth?: number;
         sticky?: boolean;
         /** Oculta la columna de la tabla */
         hidden?: boolean;
+        /**
+         * Habilita o deshabilita el ordenamiento para esta columna.
+         * @default true
+         */
+        sortable?: boolean;
+        /**
+         * Habilita el filtrado para esta columna.
+         * Por defecto está habilitado; usar `false` para ocultar el campo del drawer de filtros del `useDefaultFilterButton`.
+         * Nota: los campos de tipo `Attachments` se excluyen siempre del drawer de filtros.
+         * @default true
+         */
+        filterable?: boolean;
+        /**
+         * Número máximo de líneas visibles en la celda (aplica a Text, Note, Choice, MultiChoice, Attachments).
+         * Sobrescribe el valor general `cellLineClamp` de EFWTableProps para esta columna.
+         */
+        cellLineClamp?: number;
     }>;
+    /**
+     * Estado inicial de ordenamiento (modo uncontrolled).
+     * @example [{ id: 'firstName', desc: false }]
+     */
+    defaultSorting?: EFWTableSortingState;
+    /**
+     * Callback invocado cuando el usuario cambia el orden de una columna.
+     *
+     * Si se provee, se activa el modo **server-side sorting**: TanStack no ordena los datos
+     * internamente y delega esa responsabilidad al desarrollador. El desarrollador debe
+     * obtener los datos ordenados (por ejemplo, via API) y actualizar la tabla usando
+     * `tableMethods.replaceAllItems()`.
+     *
+     * Si no se provee, el ordenamiento es **client-side**: TanStack ordena los datos
+     * automáticamente con `getSortedRowModel`.
+     *
+     * @param sortingState - Estado actual de ordenamiento `{ id: string; desc: boolean }[]`
+     * @param tableMethods - Métodos de la tabla para actualizar los datos
+     *
+     * @example
+     * // Server-side sorting
+     * const handleSortChange = async (sortingState, tableMethods) => {
+     *   const [sort] = sortingState;
+     *   if (!sort) return;
+     *   const data = await api.getItems({ sortBy: sort.id, sortDir: sort.desc ? 'desc' : 'asc' });
+     *   tableMethods.replaceAllItems(data);
+     * };
+     */
+    onSortChange?: (sortingState: EFWTableSortingState, tableMethods: EFWTableMethods<T>) => void;
+    /**
+     * Callback invocado cuando el usuario cambia los filtros activos.
+     *
+     * Si se provee, se activa el modo **server-side filtering**: TanStack no filtra los datos
+     * internamente y delega esa responsabilidad al desarrollador. El desarrollador debe
+     * obtener los datos filtrados (por ejemplo, via API) y actualizar la tabla usando
+     * `tableMethods.replaceAllItems()`.
+     *
+     * Si no se provee, el filtrado es **client-side**: los datos se filtran automáticamente
+     * con `getFilteredRowModel` de TanStack.
+     *
+     * @param filters - Valores de filtro actuales por campo `{ [internalName]: filterValue }`
+     * @param tableMethods - Métodos de la tabla para actualizar los datos
+     *
+     * @example
+     * // Server-side filtering
+     * const handleFilterChange = async (filters, tableMethods) => {
+     *   const data = await api.getItems({ filters });
+     *   tableMethods.replaceAllItems(data);
+     * };
+     */
+    onFilterChange?: (filters: FilterValues<T>, tableMethods: EFWTableMethods<T>) => void;
     useVirtualization?: boolean;
     getFieldIcon?: (internalName: string, item: EFWTableItem<T>) => React.ReactNode;
     tableRef?: React.MutableRefObject<EFWTableRef<T>>;
     onItemsChange?: (newItems: EFWTableItem<T>[]) => void;
     onBeforeDelete?: (selectedItems: EFWTableItem<T>[], selectedIndexes: number[]) => number[] | Promise<number[]>;
     /** Botones que se renderizan siempre, independientemente de la selección. */
-    alwaysButtons?: EFWTableCommandBarButton<T>[];
+    alwaysButtons?: EFWTableCommandBarButtonInput<T>[];
     /** Botones que se renderizan solo cuando no hay filas seleccionadas. */
-    noSelectionButtons?: EFWTableCommandBarButton<T>[];
+    noSelectionButtons?: EFWTableCommandBarButtonInput<T>[];
     /** Botones que se renderizan solo cuando hay exactamente una fila seleccionada. */
-    singleSelectionButtons?: EFWTableCommandBarButton<T>[];
+    singleSelectionButtons?: EFWTableCommandBarButtonInput<T>[];
     /** Botones que se renderizan cuando hay más de una fila seleccionada. */
-    multiSelectionButtons?: EFWTableCommandBarButton<T>[];
+    multiSelectionButtons?: EFWTableCommandBarButtonInput<T>[];
+    /**
+     * Callback genérico de scroll sobre el contenedor interno de la tabla.
+     */
     onScroll?: (event: React.UIEvent<HTMLDivElement>) => void;
+    /**
+     * Se dispara cuando el scroll vertical está cerca del final de la tabla.
+     * Útil para implementar infinite scroll sin repetir lógica en cada consumidor.
+     */
+    onScrollEnd?: () => void;
+    /**
+     * Distancia en píxeles antes del final para disparar `onScrollEnd`.
+     * @default 500
+     */
+    scrollEndThreshold?: number;
+    /**
+     * Muestra un indicador de carga al final del contenido de la tabla.
+     * No se considera una fila real y no participa en selección ni virtualización.
+     */
+    loadingMore?: boolean;
     addButtonConfig?: DefaultDrawerButtonProps<T>;
     updateButtonConfig?: DefaultDrawerButtonProps<T>;
     deleteButtonConfig?: DefaultDrawerButtonProps<T>;
+    filterButtonConfig?: DefaultFilterButtonProps<T>;
     /**
      * Callback que se ejecuta antes de agregar elementos
      *
@@ -301,9 +498,9 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
      *
      * @param {Array<{index: number, item: Partial<EFWTableItem>}>} items - Elementos a actualizar con sus índices
      * @param {EFWTableMethods} tableMethods - Métodos de la tabla para operaciones adicionales
-     * @returns {Promise<OperationResult<EFWTableItem> | void>}
+     * @returns {Promise<BeforeUpdateItemsResult<EFWTableItem> | void>}
      *   - `void`: Continúa con la operación normal de actualización
-     *   - `OperationResult`: Controla exactamente qué elementos se actualizan
+     *   - `BeforeUpdateItemsResult`: Controla qué elementos se actualizan (el item en `successful` es opcional)
      *
      * @example
      * // Validación de permisos - devuelve void si todo OK
@@ -356,7 +553,7 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
     beforeUpdateItems?: (items: {
         index: number;
         item: Partial<EFWTableItem<T>>;
-    }[], tableMethods: EFWTableMethods<T>) => Promise<OperationResult<EFWTableItem<T>> | void>;
+    }[], tableMethods: EFWTableMethods<T>) => Promise<BeforeUpdateItemsResult<EFWTableItem<T>> | void>;
     /**
      * Callback que se ejecuta antes de eliminar elementos
      *
@@ -366,9 +563,9 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
      *
      * @param {Array<{index: number, item: Partial<EFWTableItem>}>} items - Elementos a eliminar con sus índices
      * @param {EFWTableMethods} tableMethods - Métodos de la tabla para operaciones adicionales
-     * @returns {Promise<OperationResult<EFWTableItem> | void>}
+     * @returns {Promise<BeforeDeleteItemsResult<EFWTableItem> | void>}
      *   - `void`: Continúa con la operación normal de eliminación
-     *   - `OperationResult`: Controla exactamente qué elementos se eliminan
+     *   - `BeforeDeleteItemsResult`: Controla qué elementos se eliminan (el item en `successful` es opcional)
      *
      * @example
      * // Validación de dependencias - devuelve void si todo OK
@@ -443,7 +640,7 @@ export interface EFWTableProps<T extends readonly EFWFormFieldProps[] = EFWFormF
     beforeDeleteItems?: (items: {
         index: number;
         item: Partial<EFWTableItem<T>>;
-    }[], tableMethods: EFWTableMethods<T>) => Promise<OperationResult<EFWTableItem<T>> | void>;
+    }[], tableMethods: EFWTableMethods<T>) => Promise<BeforeDeleteItemsResult<EFWTableItem<T>> | void>;
     /**
      * Renderers personalizados para tipos de campo.
      * Si el renderer retorna null/undefined, se usará el renderer por defecto.
@@ -496,9 +693,6 @@ export interface CellRendererContext<T extends EFWFormFieldType> {
     columnId: string;
 }
 export type CellRenderer<T extends EFWFormFieldType> = (context: CellRendererContext<T>) => React.ReactNode;
-export type Renderers = {
-    [K in EFWFormFieldType]?: CellRenderer<K>;
-};
 export type ColumnRenderers = {
     [K in EFWFormFieldType]?: {
         default?: CellRenderer<K>;

package/dist/react-components/tables/EFWTable/components/EFWTableBody/EFWTableBody.d.ts

@@ -1,3 +1,7 @@
 import { EFWTableBodyProps } from './EFWTableBody.types';
 
-export declare const EFWTableBody: ({ tableContainerRef, useVirtualization, enableSelection, itemSize, table, gridTemplateColumns, columnSizing, stickyColumnsInfo, onRowClick, }: EFWTableBodyProps) => React.ReactElement;
+/**
+ * Wrapper exportado: delega a VirtualizedTableBody o PlainTableBody
+ * según la prop useVirtualization. Mantiene la misma interfaz pública.
+ */
+export declare const EFWTableBody: (props: EFWTableBodyProps) => React.ReactElement;

package/dist/react-components/tables/EFWTable/components/EFWTableBody/EFWTableBody.js

@@ -1,75 +1,120 @@
-import { jsxs as E, jsx as g } from "react/jsx-runtime";
-import { useEffect as f } from "react";
-import { useVirtualizer as F } from "@tanstack/react-virtual";
-import { EFWTableRow as R } from "../EFWTableRow/EFWTableRow.js";
-const S = (l) => {
-  f(() => {
-    const e = l.current;
-    if (!e) return;
-    let s = 0, d = !1, r = !1;
-    const c = () => {
-      cancelAnimationFrame(s), s = requestAnimationFrame(() => {
-        const i = e.scrollLeft > 0, a = e.scrollTop > 0;
-        i !== d && (e.classList.toggle("is-scrolling-x", i), d = i), a !== r && (e.classList.toggle("is-scrolling-y", a), r = a);
+import { jsx as g, jsxs as V } from "react/jsx-runtime";
+import { useEffect as S } from "react";
+import { useVirtualizer as A } from "@tanstack/react-virtual";
+import { EFWTableRow as x } from "../EFWTableRow/EFWTableRow.js";
+import { tokens as m } from "@fluentui/react-components";
+const B = (e) => e ? {
+  fontSize: m.fontSizeBase200,
+  lineHeight: m.lineHeightBase200
+} : {
+  fontSize: m.fontSizeBase300,
+  lineHeight: m.lineHeightBase300
+}, I = (e) => {
+  S(() => {
+    const r = e.current;
+    if (!r) return;
+    let n = 0, i = !1, a = !1;
+    const l = () => {
+      cancelAnimationFrame(n), n = requestAnimationFrame(() => {
+        const c = r.scrollLeft > 0, u = r.scrollTop > 0;
+        c !== i && (r.classList.toggle("is-scrolling-x", c), i = c), u !== a && (r.classList.toggle("is-scrolling-y", u), a = u);
       });
     };
-    return e.addEventListener("scroll", c, { passive: !0 }), c(), () => {
-      e.removeEventListener("scroll", c), cancelAnimationFrame(s);
+    return r.addEventListener("scroll", l, { passive: !0 }), l(), () => {
+      r.removeEventListener("scroll", l), cancelAnimationFrame(n);
     };
-  }, [l]);
-}, M = ({
-  tableContainerRef: l,
-  useVirtualization: e,
-  enableSelection: s = !0,
-  itemSize: d,
-  table: r,
+  }, [e]);
+}, F = ({
+  tableContainerRef: e,
+  enableSelection: r = !0,
+  itemSize: n,
+  dense: i = !0,
+  rowAnimationSignals: a,
+  table: l,
   gridTemplateColumns: c,
-  columnSizing: i,
-  stickyColumnsInfo: a,
-  onRowClick: h
+  columnSizing: u,
+  stickyColumnsInfo: h,
+  onRowClick: f,
+  onRowDoubleClick: w
 }) => {
-  const m = r.getRowModel().rows.length, w = m > 0;
-  S(w ? l : { current: null });
-  const o = e ? F({
-    count: m,
-    getScrollElement: () => l.current,
-    estimateSize: () => d,
+  const d = l.getRowModel().rows.length, p = d > 0;
+  I(p ? e : { current: null });
+  const o = A({
+    count: d,
+    getScrollElement: () => e.current,
+    estimateSize: () => n ?? i ? 32 : 44,
     measureElement: typeof window < "u" && navigator.userAgent.indexOf("Firefox") === -1 ? (t) => t?.getBoundingClientRect().height : void 0,
     overscan: 10
-  }) : null;
-  f(() => {
-    !e || !o || requestAnimationFrame(() => {
+  });
+  S(() => {
+    requestAnimationFrame(() => {
       try {
         o.measure();
       } catch (t) {
         console.warn("Error al recalcular virtualizer:", t);
       }
     });
-  }, [m > 0, e, o]);
-  const n = o?.getVirtualItems() || [], v = o?.getTotalSize() || 0, u = n.length > 0 ? n[0].start : 0, p = n.length > 0 ? v - n[n.length - 1].end : 0, x = e ? n.map((t) => ({
+  }, [d > 0, o]);
+  const s = o.getVirtualItems(), R = o.getTotalSize(), y = s.length > 0 ? s[0].start : 0, v = s.length > 0 ? R - s[s.length - 1].end : 0, T = s.map((t) => ({
     virtualRow: t,
-    row: r.getRowModel().rows[t.index]
-  })) : r.getRowModel().rows.map((t) => ({ row: t, virtualRow: null }));
-  return /* @__PURE__ */ E("div", { className: "table-body", style: { fontSize: "12px", lineHeight: "16px" }, children: [
-    e && u > 0 && /* @__PURE__ */ g("div", { style: { height: u } }),
-    x.map(({ row: t, virtualRow: y }) => /* @__PURE__ */ g(
-      R,
+    row: l.getRowModel().rows[t.index]
+  })), E = B(i);
+  return /* @__PURE__ */ V("div", { className: "table-body", style: E, children: [
+    y > 0 && /* @__PURE__ */ g("div", { style: { height: y } }),
+    T.map(({ row: t, virtualRow: z }) => /* @__PURE__ */ g(
+      x,
       {
         row: t,
-        virtualRow: y,
+        stripeIndex: z.index,
+        virtualRow: z,
+        dense: i,
+        rowAnimationSignal: t.original._rowId ? a?.[String(t.original._rowId)] : void 0,
         rowVirtualizer: o,
-        useVirtualization: e,
-        enableSelection: s,
+        useVirtualization: !0,
+        enableSelection: r,
         gridTemplateColumns: c,
-        columnSizing: i,
-        stickyColumnsInfo: a,
-        onRowClick: h
+        columnSizing: u,
+        stickyColumnsInfo: h,
+        onRowClick: f,
+        onRowDoubleClick: w
       },
-      t.id
+      t.original._rowId || t.id
     )),
-    e && p > 0 && /* @__PURE__ */ g("div", { style: { height: p } })
+    v > 0 && /* @__PURE__ */ g("div", { style: { height: v } })
   ] });
-};
+}, _ = ({
+  tableContainerRef: e,
+  enableSelection: r = !0,
+  dense: n = !0,
+  rowAnimationSignals: i,
+  table: a,
+  gridTemplateColumns: l,
+  columnSizing: c,
+  stickyColumnsInfo: u,
+  onRowClick: h,
+  onRowDoubleClick: f
+}) => {
+  const d = a.getRowModel().rows.length > 0, p = B(n);
+  return I(d ? e : { current: null }), /* @__PURE__ */ g("div", { className: "table-body", style: p, children: a.getRowModel().rows.map((o, s) => /* @__PURE__ */ g(
+    x,
+    {
+      row: o,
+      stripeIndex: s,
+      virtualRow: null,
+      dense: n,
+      rowAnimationSignal: o.original._rowId ? i?.[String(o.original._rowId)] : void 0,
+      rowVirtualizer: null,
+      useVirtualization: !1,
+      enableSelection: r,
+      gridTemplateColumns: l,
+      columnSizing: c,
+      stickyColumnsInfo: u,
+      onRowClick: h,
+      onRowDoubleClick: f
+    },
+    o.original._rowId || o.id
+  )) });
+}, q = (e) => e.useVirtualization ? /* @__PURE__ */ g(F, { ...e }) : /* @__PURE__ */ g(_, { ...e });
 export {
-  M as EFWTableBody
+  q as EFWTableBody
 };

package/dist/react-components/tables/EFWTable/components/EFWTableBody/EFWTableBody.types.d.ts

@@ -1,12 +1,14 @@
 import { Row, Table } from '@tanstack/react-table';
 import { EFWFormFieldProps } from '../../../../forms/EFWForm';
-import { EFWTableItem } from '../../EFWTable.types';
+import { EFWTableItem, EFWTableRowAnimationSignal } from '../../EFWTable.types';
 
 export interface EFWTableBodyProps {
     tableContainerRef: React.RefObject<HTMLDivElement>;
     useVirtualization: boolean;
     enableSelection?: boolean;
     itemSize: number;
+    dense: boolean;
+    rowAnimationSignals?: Record<string, EFWTableRowAnimationSignal>;
     table: Table<EFWTableItem>;
     gridTemplateColumns: string;
     columnSizing: Record<string, number>;
@@ -16,4 +18,5 @@ export interface EFWTableBodyProps {
         stickyPositions: Record<string, number>;
     };
     onRowClick: (row: Row<EFWTableItem>, event?: React.MouseEvent) => void;
+    onRowDoubleClick?: (row: Row<EFWTableItem>, event?: React.MouseEvent) => void;
 }

package/dist/react-components/tables/EFWTable/components/EFWTableCell/EFWTableCell.d.ts

@@ -1,20 +1,9 @@
 import { default as React } from 'react';
-import { Cell } from '@tanstack/react-table';
-import { EFWTableItem } from '../../EFWTable.types';
+import { EFWTableCellProps } from './EFWTableCell.types';
 
-interface EFWTableCellProps {
-    cell: Cell<EFWTableItem, unknown>;
-    columnSizing: Record<string, number>;
-    stickyColumnsInfo: {
-        stickyColumns: string[];
-        stickyPositions: Record<string, number>;
-    };
-    useVirtualization: boolean;
-}
 /**
  * Componente EFWTableCell exportado directamente sin memoización.
  * TanStack Table maneja internamente el estado y los objetos cell
  * pueden mantener la misma referencia mientras cambia su estado interno.
  */
 export declare const EFWTableCell: React.FC<EFWTableCellProps>;
-export {};