@m4l/components 9.4.13 → 9.4.15

package/components/datagrids/formatters/ColumnUncertaintyFormatter/ColumnUncertaintyGroupFormatter.d.ts

@@ -0,0 +1,15 @@
+import { ColumnUncertaintyFormatterProps } from './types';
+import { RenderGroupCellProps } from 'react-data-grid';
+/**
+ * Formatter para mostrar valores de incertidumbre en filas de grupo (TreeDataGrid).
+ *
+ * Esta función es utilizada cuando el TreeDataGrid agrupa filas y necesita
+ * mostrar el valor de incertidumbre en el encabezado del grupo. Usa la primera fila
+ * del grupo (childRows[0]) como fuente de datos representativa.
+ * @param props - Propiedades del formatter que incluyen:
+ *                - fieldValue: Campo con los rangos de incertidumbre
+ *                - fieldSymbol: Campo con el símbolo
+ *                - fieldUnit: Campo con la unidad
+ * @returns Función que recibe RenderGroupCellProps y retorna el UncertaintyFormatter
+ */
+export declare const ColumnUncertaintyGroupFormatter: <TRow>(props: ColumnUncertaintyFormatterProps<TRow>) => (groupProps: RenderGroupCellProps<TRow>) => import("react/jsx-runtime").JSX.Element;

package/components/datagrids/formatters/ColumnUncertaintyFormatter/ColumnUncertaintyGroupFormatter.js

@@ -0,0 +1,27 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import React from "react";
+import { U as UncertaintyFormatter } from "../../../formatters/UncertaintyFormatter/UncertaintyFormatter.js";
+const ColumnUncertaintyGroupFormatter = (props) => {
+  const { Component = React.Fragment, fieldValue, fieldSymbol, fieldUnit } = props;
+  return (groupProps) => {
+    const { childRows } = groupProps;
+    if (childRows.length === 0) {
+      return /* @__PURE__ */ jsx(Fragment, { children: "-" });
+    }
+    const representativeRow = childRows[0];
+    return /* @__PURE__ */ jsx(
+      UncertaintyFormatter,
+      {
+        obProps: representativeRow,
+        ...props,
+        fieldValue: fieldValue.toString(),
+        fieldSymbol: fieldSymbol.toString(),
+        fieldUnit: fieldUnit.toString(),
+        Component
+      }
+    );
+  };
+};
+export {
+  ColumnUncertaintyGroupFormatter as C
+};

package/components/datagrids/formatters/ColumnUncertaintyFormatter/index.d.ts

@@ -1,3 +1,4 @@
 export { ColumnUncertaintyFormatter } from './formatter';
+export { ColumnUncertaintyGroupFormatter } from './ColumnUncertaintyGroupFormatter';
 export type { ColumnUncertaintyFormatterProps } from './types';
 export { useColumnUncertanity } from './useColumnUncertainty';

package/components/datagrids/formatters/ColumnUncertaintyFormatter/useColumnUncertainty.d.ts

@@ -5,6 +5,7 @@ import { ColumnUncertaintyFormatterProps } from './types';
  */
 export declare const useColumnUncertanity: <TRow>(props: ColumnUncertaintyFormatterProps<TRow>) => {
     formatter: (formatterProps: import('react-data-grid').RenderCellProps<TRow, unknown>) => import("react/jsx-runtime").JSX.Element;
+    renderGroupCell: (groupProps: import('react-data-grid').RenderGroupCellProps<TRow, unknown>) => import("react/jsx-runtime").JSX.Element;
     customFilter: (row: TRow, value: string) => boolean;
     customSort: (a: TRow, b: TRow) => 0 | 1 | -1;
 };

package/components/datagrids/formatters/ColumnUncertaintyFormatter/useColumnUncertainty.js

@@ -1,6 +1,7 @@
 import { useState, useRef, useEffect, useMemo } from "react";
 import { deepEqual } from "fast-equals";
 import { g as getUncertaintyFormat } from "../../../formatters/UncertaintyFormatter/UncertaintyFormatter.js";
+import { C as ColumnUncertaintyGroupFormatter } from "./ColumnUncertaintyGroupFormatter.js";
 import { C as ColumnUncertaintyFormatter } from "./formatter.js";
 import { g as getColumnKey } from "../../helpers/shared/getColumnKey/getColumnKey.js";
 const getCustomUncertaintyFilter = (props) => {
@@ -44,6 +45,7 @@ const useColumnUncertanity = (props) => {
   }, [props]);
   return useMemo(() => ({
     formatter: ColumnUncertaintyFormatter(stateProps),
+    renderGroupCell: ColumnUncertaintyGroupFormatter(stateProps),
     customFilter: getCustomUncertaintyFilter(stateProps),
     customSort: getCustomUncertaintySort(stateProps)
   }), [stateProps]);

package/components/datagrids/helpers/shared/getInitialColumnsConfig/getInitialColumnsConfig.js

@@ -13,6 +13,7 @@ const getInitialColumnsConfig = (id, columns, viewMode, defaultConfig, viewSpeci
   return columns.map((column, index) => {
     const existingConfig = columnsConfig.find((c) => c.key === column.key);
     const columnConfigIndex = existingConfig ? columnsConfig.indexOf(existingConfig) : -1;
+    const groupedColumnsCount = columns.slice(0, index).filter((c) => c.grouped === true).length;
     const baseConfig = {
       key: column.key,
       name: typeof column.name === "string" ? column.name : String(column.name),
@@ -22,10 +23,17 @@ const getInitialColumnsConfig = (id, columns, viewMode, defaultConfig, viewSpeci
       originalIndex: index,
       originalVisible: column.visible === void 0 ? true : column.visible
     };
+    const groupingConfig = viewMode === "table" ? {
+      grouped: existingConfig?.grouped ?? column.grouped ?? false,
+      groupOrder: existingConfig?.groupOrder ?? (column.grouped ? groupedColumnsCount : index),
+      originalGrouped: column.grouped ?? false,
+      originalGroupOrder: column.grouped ? groupedColumnsCount : index
+    } : {};
     return {
       ...baseConfig,
       ...viewSpecificDefaults,
       ...originalViewSpecificDefaults,
+      ...groupingConfig,
       ...existingConfig || {}
     };
   }).sort((a, b) => a.index - b.index);

package/components/datagrids/helpers/shared/getViewSpecificConfig/getViewSpecificConfig.js

@@ -1,10 +1,17 @@
 const getViewSpecificConfig = (viewMode) => {
   const configs = {
     table: {
-      defaults: { frozen: false },
-      originalDefaults: { originalFrozen: false },
+      defaults: { frozen: false, grouped: false, groupOrder: 0 },
+      originalDefaults: { originalFrozen: false, originalGrouped: false, originalGroupOrder: 0 },
+      /**
+       * Extrae las propiedades originales de frozen, grouped y groupOrder de un item.
+       * @param item - Item del cual extraer las propiedades
+       * @returns Objeto con las propiedades originales
+       */
       dynamicOriginalProperty: (item) => ({
-        originalFrozen: item?.frozen ?? false
+        originalFrozen: item?.frozen ?? false,
+        originalGrouped: item?.grouped ?? false,
+        originalGroupOrder: item?.groupOrder ?? 0
       })
     },
     cards: {

package/components/datagrids/hooks/useChangeColumnsOrder/useChangeColumnsOrder.d.ts

@@ -3,6 +3,7 @@ import { UseChangeColumnsOrderParams, UseChangeColumnsOrderReturn } from './type
  * Hook para manejar el cambio de orden de columnas.
  *
  * Reordena las columnas y llama a onChangeColumnsConfig para persistir.
+ * También recalcula groupOrder si las columnas están agrupadas.
  * @param getConfigColumns Función para obtener la configuración de columnas
  * @param onChangeColumnsConfig Función para cambiar la configuración de columnas
  * @returns Función para cambiar el orden de columnas

package/components/datagrids/hooks/useChangeColumnsOrder/useChangeColumnsOrder.js

@@ -21,10 +21,18 @@ const useChangeColumnsOrder = ({
         0,
         reorderedConfig.splice(sourceColumnIndex, 1)[0]
       );
-      const configWithUpdatedIndexes = reorderedConfig.map((col, idx) => ({
-        ...col,
-        index: idx
-      }));
+      let groupOrderCounter = 0;
+      const configWithUpdatedIndexes = reorderedConfig.map((col, idx) => {
+        const updatedCol = {
+          ...col,
+          index: idx
+        };
+        if (col.grouped) {
+          updatedCol.groupOrder = groupOrderCounter;
+          groupOrderCounter++;
+        }
+        return updatedCol;
+      });
       onChangeColumnsConfig(viewModeParam, configWithUpdatedIndexes);
     },
     [getConfigColumns, onChangeColumnsConfig]

package/components/datagrids/icons.d.ts

@@ -20,6 +20,7 @@ export declare const pathIcons: {
     freezeColumn: string;
     unfreezeColumn: string;
     hideColumn: string;
+    groupColumn: string;
     viewTable: string;
     viewCards: string;
     info: string;
@@ -28,4 +29,8 @@ export declare const pathIcons: {
     smartphone: string;
     internet: string;
     edit: string;
+    group: string;
+    removeGroup: string;
+    groupUp: string;
+    groupDown: string;
 };

package/components/datagrids/icons.js

@@ -24,7 +24,11 @@ const pathIcons = {
   viewCards: "frontend/components/data_grid/assets/icons/card.svg",
   info: "frontend/components/data_grid/assets/icons/info.svg",
   expanded: "frontend/components/data_grid/assets/icons/expanded.svg",
-  edit: "frontend/components/EditLabel/assets/icons/pencil.svg"
+  edit: "frontend/components/EditLabel/assets/icons/pencil.svg",
+  group: "frontend/components/data_grid/assets/icons/group.svg",
+  removeGroup: "frontend/components/data_grid/assets/icons/remove_group.svg",
+  groupUp: "frontend/components/data_grid/assets/icons/group_up.svg",
+  groupDown: "frontend/components/data_grid/assets/icons/group_down.svg"
 };
 export {
   pathIcons as p

package/components/datagrids/index.d.ts

@@ -1,7 +1,8 @@
 export { DataGrid } from './components/DataGridMain';
+export { TreeDataGrid } from './components/TreeDataGrid';
 export * from './formatters';
 export type { Column, RenderEditCellProps, RenderCellProps, } from 'react-data-grid';
-export type { RowKey, ChangeConfig, ChangeUserColumn, RowActionsGetter, RowKeyGetter, } from './types';
+export type { RowKey, ChangeConfig, ChangeUserColumn, RowActionsGetter, RowKeyGetter, TreeProps, TreeDataGridProps, } from './types';
 export type { IGridConfigExtended, BaseConfigColumn, } from './contexts/DataGridContext/types';
 export type { IGridConfig } from './helpers/persistence/getColumnsWidth/types';
 export { getDataGridComponentsDictionary } from './dictionary';

package/components/datagrids/slots/DataGridEnum.d.ts

@@ -53,7 +53,9 @@ export declare enum TableSlots {
     editorCellWrapper = "editorCellWrapper",
     editablePlaceholder = "editablePlaceholder",
     editLabel = "editLabel",
-    iconButtonEdit = "iconButtonEdit"
+    iconButtonEdit = "iconButtonEdit",
+    defaultRenderGroupCellRoot = "defaultRenderGroupCellRoot",
+    defaultRenderGroupCellText = "defaultRenderGroupCellText"
 }
 export declare enum TextEditorSlots {
     inputTexEditor = "inputTexEditor"

package/components/datagrids/slots/DataGridEnum.js

@@ -57,6 +57,8 @@ var TableSlots = /* @__PURE__ */ ((TableSlots2) => {
   TableSlots2["editablePlaceholder"] = "editablePlaceholder";
   TableSlots2["editLabel"] = "editLabel";
   TableSlots2["iconButtonEdit"] = "iconButtonEdit";
+  TableSlots2["defaultRenderGroupCellRoot"] = "defaultRenderGroupCellRoot";
+  TableSlots2["defaultRenderGroupCellText"] = "defaultRenderGroupCellText";
   return TableSlots2;
 })(TableSlots || {});
 var TextEditorSlots = /* @__PURE__ */ ((TextEditorSlots2) => {

package/components/datagrids/slots/DataGridSlot.d.ts

@@ -97,3 +97,5 @@ export declare const ControlNavigateStyled: import('@emotion/styled').StyledComp
  * ****************
  */
 export declare const ColumnIconFormatterStyled: import('@emotion/styled').StyledComponent<any, Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').ClassAttributes<HTMLDivElement> | keyof import('react').HTMLAttributes<HTMLDivElement>>, {}>;
+export declare const DefaultRenderGroupCellRootStyled: import('@emotion/styled').StyledComponent<any, Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, keyof import('react').ClassAttributes<HTMLSpanElement> | keyof import('react').HTMLAttributes<HTMLSpanElement>>, {}>;
+export declare const DefaultRenderGroupCellTextStyled: import('@emotion/styled').StyledComponent<any, Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, keyof import('react').ClassAttributes<HTMLSpanElement> | keyof import('react').HTMLAttributes<HTMLSpanElement>>, {}>;

package/components/datagrids/slots/DataGridSlot.js

@@ -1,7 +1,7 @@
 import { styled } from "@mui/material/styles";
 import { MenuList, InputBase } from "@mui/material";
 import { D as DATAGRID_PREFIX_NAME } from "../constants.js";
-import { D as DataGridSlots, T as TextEditorSlots, A as ActionsSlots, C as ControlNavigateSlots, b as TableSlots, R as RowsCountSlots, a as ColumnsConfigSlots, c as ColumnIconFormatterSlots } from "./DataGridEnum.js";
+import { T as TextEditorSlots, D as DataGridSlots, b as TableSlots, A as ActionsSlots, C as ControlNavigateSlots, R as RowsCountSlots, a as ColumnsConfigSlots, c as ColumnIconFormatterSlots } from "./DataGridEnum.js";
 import { d as dataGridStyles } from "../Datagrid.styles.js";
 import { I as Icon } from "../../Icon/Icon.js";
 import { C as Card } from "../../Card/Card.js";
@@ -231,6 +231,14 @@ styled("div", {
   name: DATAGRID_PREFIX_NAME,
   slot: ColumnIconFormatterSlots.columnIconFormatter
 })(dataGridStyles.columnIconFormatter);
+const DefaultRenderGroupCellRootStyled = styled("span", {
+  name: DATAGRID_PREFIX_NAME,
+  slot: TableSlots.defaultRenderGroupCellRoot
+})(dataGridStyles.defaultRenderGroupCellRoot);
+const DefaultRenderGroupCellTextStyled = styled("span", {
+  name: DATAGRID_PREFIX_NAME,
+  slot: TableSlots.defaultRenderGroupCellText
+})(dataGridStyles.defaultRenderGroupCellText);
 export {
   ActionsRootStyled as A,
   TableContainerStyled as B,
@@ -250,10 +258,12 @@ export {
   MenuListStyled as P,
   HeaderRenderClickStyled as Q,
   RowsCountRootStyled as R,
-  CheckboxCellWrapperStyled as S,
+  DefaultRenderGroupCellRootStyled as S,
   TextToggleCardButtonStyled as T,
+  DefaultRenderGroupCellTextStyled as U,
   ValueColumnStyled as V,
   WrapperSkeletonStyled as W,
+  CheckboxCellWrapperStyled as X,
   ControlNavigateStyled as a,
   RowsCountLabelStyled as b,
   RowsCountValueStyled as c,

package/components/datagrids/tests/helpers/types.d.ts

@@ -12,6 +12,16 @@ export interface SeedProps {
     withMultipleIcons?: boolean;
     withInteractiveCheck?: boolean;
     withNestedValue?: boolean;
+    /**
+     * Si es true, genera valores anidados con algunos null/undefined
+     * para mostrar el comportamiento del defaultValue ('-')
+     */
+    withNestedValueWithNulls?: boolean;
+    /**
+     * Si es true, genera valores anidados con null/undefined
+     * y usa un defaultValue personalizado ('N/A')
+     */
+    withNestedValueCustomDefaultValue?: boolean;
     withPoints?: boolean;
     withPrice?: boolean;
     withUncertainty?: boolean;

package/components/datagrids/types.d.ts

@@ -39,6 +39,18 @@ declare module 'react-data-grid' {
         formatter?: (props: any) => JSX.Element;
         /** @deprecated Usa renderEditCell en lugar de editor. Este atributo será removido en una futura versión. */
         editor?: Maybe<(props: RenderEditCellProps<TRow, TSummaryRow>) => ReactNode>;
+        /**
+         * Si true, la columna puede ser agrupada/desagrupada por el usuario.
+         * Solo aplica para TreeDataGrid.
+         */
+        groupable?: boolean;
+        /**
+         * Si true, la columna está agrupada por defecto.
+         * - Con `groupable: true`: el usuario puede cambiar la agrupación.
+         * - Sin `groupable` o `groupable: false`: agrupación estática, no se puede cambiar.
+         * Solo aplica para TreeDataGrid.
+         */
+        grouped?: boolean;
     }
 }
 export declare type RowKey = string | number;
@@ -319,3 +331,43 @@ export type DataGridOwnerState<TRow, TSummaryRow, TKey extends RowKey = RowKey>
 };
 export type DataGridSlotsType = DataGridSlots | TextEditorSlots | ActionsSlots | RowsCountSlots | ColumnsConfigSlots | TableSlots | ControlNavigateSlots | ColumnIconFormatterSlots;
 export type DataGridStyles = OverridesStyleRules<DataGridSlotsType, typeof DATAGRID_PREFIX_NAME, Theme>;
+/**
+ * Props específicas de TreeDataGrid (de react-data-grid)
+ * Estas props controlan la funcionalidad de agrupación jerárquica.
+ *
+ * NOTA: groupBy se calcula automáticamente desde columnsConfig.grouped
+ * ordenadas por groupOrder. El desarrollador define grouped/groupable en columns.
+ */
+export interface TreeProps<TRow> {
+    /**
+     * Función que agrupa las filas por una columna.
+     *
+     * OPCIONAL: Si no se pasa, usa un rowGrouper genérico que agrupa
+     * por el valor directo de la columna (row[columnKey]).
+     *
+     * Solo necesitas pasar un rowGrouper personalizado si quieres
+     * transformar los valores antes de agrupar, por ejemplo:
+     * - Agrupar fechas por mes ("Enero 2024")
+     * - Agrupar números por rango ("$40k - $60k")
+     * @see defaultRowGrouper en helpers/defaultRowGrouper
+     */
+    rowGrouper?: (rows: readonly TRow[], columnKey: string) => Record<string, readonly TRow[]>;
+    /** IDs de grupos expandidos */
+    expandedGroupIds?: ReadonlySet<unknown>;
+    /** Callback cuando cambian los grupos expandidos */
+    onExpandedGroupIdsChange?: (expandedGroupIds: Set<unknown>) => void;
+}
+/**
+ * Props completas de TreeDataGrid.
+ * Extiende DataGridProps pero sin cardsViewConfig ni defaultViewMode
+ * ya que TreeDataGrid solo soporta vista de tabla.
+ */
+export interface TreeDataGridProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Omit<DataGridProps<TRow, TSummaryRow, TKey>, 'cardsViewConfig' | 'defaultViewMode'>, TreeProps<TRow> {
+}
+/**
+ * Props para TableView con soporte opcional para TreeDataGrid
+ */
+export type TableViewProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> = GridProps<TRow, TSummaryRow, TKey> & {
+    /** Props para TreeDataGrid. Si se pasan, usa TreeDataGrid en lugar de DataGrid */
+    treeProps?: TreeProps<TRow>;
+};

package/components/datagrids/views/CardsView/hooks/useProcessedColumns/useProcessedColumns.d.ts

@@ -47,4 +47,6 @@ export declare function useProcessedColumns<TRow, TSummaryRow>(columns: readonly
     customSort?: ((a: TRow, b: TRow) => number) | undefined;
     formatter?: ((props: any) => JSX.Element) | undefined;
     editor?: import('@m4l/core').Maybe<(props: import('react-data-grid').RenderEditCellProps<TRow, TSummaryRow>) => import('react').ReactNode>;
+    groupable?: boolean;
+    grouped?: boolean;
 }[];

package/components/datagrids/views/CardsView/hooks/useProcessedColumns/useProcessedColumns.js

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
-import { d as DATAGRID_SELECT_COLUMN_KEY, e as DATAGRID_ACTIONS_COLUMN_KEY } from "../../../../constants.js";
+import { SELECT_COLUMN_KEY } from "react-data-grid";
+import { d as DATAGRID_ACTIONS_COLUMN_KEY } from "../../../../constants.js";
 import { u as useDataGrid } from "../../../../hooks/shared/useDataGrid/useDataGrid.js";
 function useProcessedColumns(columns, options = {}) {
   const { applyVisibilityFilter = true } = options;
@@ -10,7 +11,7 @@ function useProcessedColumns(columns, options = {}) {
   );
   return useMemo(() => {
     const processedColumns = columns.filter((column) => {
-      if (column.key === DATAGRID_SELECT_COLUMN_KEY || column.key === DATAGRID_ACTIONS_COLUMN_KEY) {
+      if (column.key === SELECT_COLUMN_KEY || column.key === DATAGRID_ACTIONS_COLUMN_KEY) {
         return false;
       }
       if (!applyVisibilityFilter) {

package/components/datagrids/views/TableView/TableView.d.ts

@@ -1,7 +1,7 @@
-import { DataGridProps } from 'react-data-grid';
-import { GridProps, RowKey } from '../../types';
+import { RowKey, TableViewProps } from '../../types';
 /**
  * Componente que renderiza la tabla con las filas y columnas
- * Acepta todos los props de DataGrid y prioriza las configuraciones personalizadas
+ * Acepta todos los props de DataGrid y prioriza las configuraciones personalizadas.
+ * Si se proporcionan treeProps, renderiza TreeDataGrid en lugar de DataGrid.
  */
-export declare function TableView<TRow, TSummaryRow, TKey extends RowKey = RowKey>(props: GridProps<TRow, TSummaryRow, TKey> & Omit<DataGridProps<TRow, TSummaryRow>, keyof GridProps<TRow, TSummaryRow, TKey>>): import("react/jsx-runtime").JSX.Element;
+export declare function TableView<TRow, TSummaryRow, TKey extends RowKey = RowKey>(props: TableViewProps<TRow, TSummaryRow, TKey>): import("react/jsx-runtime").JSX.Element;

package/components/datagrids/views/TableView/TableView.js

@@ -1,10 +1,12 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useMemo, useState, useRef, useEffect } from "react";
-import DataGrid from "react-data-grid";
+import DataGrid, { TreeDataGrid } from "react-data-grid";
 import { DndProvider } from "react-dnd";
 import { HTML5Backend } from "react-dnd-html5-backend";
 import { B as TableContainerStyled, y as TableWrapperDataGridStyled } from "../../slots/DataGridSlot.js";
 import { u as useSortColumnsRows } from "./hooks/useSortColumnsRows/useSortColumnsRows.js";
+import { g as getGroupBy } from "./helpers/getGroupBy/getGroupBy.js";
+import { d as defaultRowGrouper } from "./helpers/defaultRowGrouper/defaultRowGrouper.js";
 import { u as useHeaderMenuActions } from "./hooks/useHeaderMenuActions/useHeaderMenuActions.js";
 import { f as filterHeight } from "./subcomponents/SelectColumn/SelectColumn.js";
 import { H as HeaderRenderClick } from "./subcomponents/HeaderRenderClick/HeaderRenderClick.js";
@@ -21,6 +23,7 @@ function TableView(props) {
     onSelectedRowsChange,
     defaultColumnOptions: defaultColumnOptionsProp,
     focusOnRowKey,
+    treeProps,
     ...restProps
   } = props;
   const renderCheckbox = (formatterProps) => {
@@ -61,8 +64,16 @@ function TableView(props) {
     currentRowHeightVariant,
     size,
     sortColumns,
-    setSortColumns
+    setSortColumns,
+    columnsConfig
   } = useDataGrid();
+  const groupBy = useMemo(() => {
+    if (!treeProps) {
+      return [];
+    }
+    return getGroupBy(columnsConfig);
+  }, [columnsConfig, treeProps]);
+  const rowGrouper = treeProps?.rowGrouper ?? defaultRowGrouper;
   const ref_data_grid = useRef(null);
   const [popoverState, setPopoverState] = useState({
     anchorEl: null,
@@ -150,7 +161,34 @@ function TableView(props) {
     {
       ownerState: { size, currentRowHeightVariant, currentRowHeight },
       children: [
-        /* @__PURE__ */ jsx(DndProvider, { backend: HTML5Backend, context: window, children: /* @__PURE__ */ jsx(
+        /* @__PURE__ */ jsx(DndProvider, { backend: HTML5Backend, context: window, children: treeProps ? /* @__PURE__ */ jsx(
+          TreeDataGrid,
+          {
+            className: "rdg-light",
+            ref: ref_data_grid,
+            headerRowHeight: activeFilters ? currentRowHeaderHeight + filterHeight : currentRowHeaderHeight,
+            columns: finalColumns,
+            sortColumns,
+            onSortColumnsChange: handleSortColumnsChange,
+            onColumnResize,
+            rows: finalRows,
+            onRowsChange,
+            selectedRows,
+            onSelectedRowsChange,
+            onCellClick,
+            rowHeight: currentRowHeight,
+            rowKeyGetter,
+            renderers: {
+              renderCheckbox
+            },
+            defaultColumnOptions,
+            groupBy,
+            rowGrouper,
+            expandedGroupIds: treeProps.expandedGroupIds,
+            onExpandedGroupIdsChange: treeProps.onExpandedGroupIdsChange,
+            ...restProps
+          }
+        ) : /* @__PURE__ */ jsx(
           DataGrid,
           {
             className: "rdg-light",

package/components/datagrids/views/TableView/helpers/defaultRowGrouper/defaultRowGrouper.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RowGrouper genérico por defecto.
+ *
+ * Se usa cuando NO pasas un rowGrouper personalizado al TreeDataGrid.
+ * Agrupa las filas usando el valor directo de la columna.
+ *
+ * Ideal para agrupar por campos de texto como:
+ * - Departamento
+ * - Estado
+ * - Ubicación
+ * @param rows - Todas las filas de la tabla
+ * @param columnKey - El nombre de la columna por la que agrupar (ej: 'department')
+ * @returns Un objeto donde cada llave es un valor único y cada valor es un array de filas
+ * @example
+ * const rows = [
+ *   { id: 1, name: 'Juan', department: 'Ventas' },
+ *   { id: 2, name: 'María', department: 'Tecnología' },
+ *   { id: 3, name: 'Pedro', department: 'Ventas' },
+ * ];
+ *
+ * const groups = defaultRowGrouper(rows, 'department');
+ * // Resultado:
+ * // {
+ * //   'Ventas': [Juan, Pedro],
+ * //   'Tecnología': [María]
+ * // }
+ */
+export declare const defaultRowGrouper: <TRow>(rows: readonly TRow[], columnKey: string) => Record<string, readonly TRow[]>;

package/components/datagrids/views/TableView/helpers/defaultRowGrouper/defaultRowGrouper.js

@@ -0,0 +1,15 @@
+const defaultRowGrouper = (rows, columnKey) => {
+  const groups = {};
+  for (const row of rows) {
+    const rawValue = row[columnKey];
+    const groupKey = String(rawValue ?? "");
+    if (!groups[groupKey]) {
+      groups[groupKey] = [];
+    }
+    groups[groupKey].push(row);
+  }
+  return groups;
+};
+export {
+  defaultRowGrouper as d
+};

package/components/datagrids/views/TableView/helpers/defaultRowGrouper/defaultRowGrouper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/datagrids/views/TableView/helpers/defaultRowGrouper/index.d.ts

@@ -0,0 +1 @@
+export { defaultRowGrouper } from './defaultRowGrouper';

package/components/datagrids/views/TableView/helpers/defaultRowGrouper/index.js

@@ -0,0 +1 @@
+

package/components/datagrids/views/TableView/helpers/getGroupBy/getGroupBy.d.ts

@@ -0,0 +1,20 @@
+import { IConfigColumn } from '../../../../contexts/DataGridContext/types';
+/**
+ * Calcula el array de keys de columnas que deben agruparse.
+ *
+ * Esta función:
+ * 1. Filtra las columnas que tienen grouped: true
+ * 2. Las ordena por groupOrder (menor = primer nivel de agrupación)
+ * 3. Retorna un array con las keys de esas columnas
+ * @param columnsConfig - Array de configuración de columnas del DataGrid
+ * @returns Array de keys de columnas ordenadas por nivel de agrupación
+ * @example
+ * // Si columnsConfig tiene:
+ * // - department: { grouped: true, groupOrder: 0 }
+ * // - team: { grouped: true, groupOrder: 1 }
+ * // - name: { grouped: false }
+ *
+ * const groupBy = getGroupBy(columnsConfig);
+ * // Resultado: ['department', 'team']
+ */
+export declare const getGroupBy: (columnsConfig: IConfigColumn[]) => string[];

package/components/datagrids/views/TableView/helpers/getGroupBy/getGroupBy.js

@@ -0,0 +1,13 @@
+const getGroupBy = (columnsConfig) => {
+  const groupedColumns = columnsConfig.filter(
+    (column) => column.grouped === true
+  );
+  const sortedColumns = groupedColumns.sort(
+    (columnA, columnB) => (columnA.groupOrder ?? 0) - (columnB.groupOrder ?? 0)
+  );
+  const groupByKeys = sortedColumns.map((column) => column.key);
+  return groupByKeys;
+};
+export {
+  getGroupBy as g
+};

package/components/datagrids/views/TableView/helpers/getGroupBy/getGroupBy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/datagrids/views/TableView/helpers/getGroupBy/index.d.ts

@@ -0,0 +1 @@
+export { getGroupBy } from './getGroupBy';

package/components/datagrids/views/TableView/helpers/getGroupBy/index.js

@@ -0,0 +1 @@
+

package/components/datagrids/views/TableView/helpers/index.d.ts

@@ -1 +1,3 @@
 export { getDragHeaderRenderer } from './getDragHeaderRenderer';
+export { getGroupBy } from './getGroupBy';
+export { defaultRowGrouper } from './defaultRowGrouper';