@m4l/components 9.3.41-JT04122025.beta.3 → 9.3.43-BE20251205-beta.1

package/components/DataGrid/DataGrid.js

@@ -34,12 +34,8 @@ function DataGrid(props) {
     dataTestId = "",
     customHeader: CustomHeader,
     visibleCustomHeader = true,
-    defaultConfig,
-    onChangeConfig,
     defaultUserColumns,
-    // deprecated
     onChangeUserColumns,
-    // deprecated
     size,
     externalSortSettings,
     externalFilterSettings,
@@ -95,10 +91,8 @@ function DataGrid(props) {
           checkedRowsMultiple,
           rowKeyGetter,
           rows,
-          defaultConfig,
-          onChangeConfig,
-          defaultUserColumns,
           onChangeUserColumns,
+          defaultUserColumns,
           size: currentSize,
           externalSortSettings,
           externalFilterSettings,

package/components/DataGrid/contexts/DataGridContext/index.js

@@ -1,33 +1,152 @@
 import { jsx } from "react/jsx-runtime";
-import { useState, useEffect, useMemo, createContext } from "react";
-import { useFirstRender } from "@m4l/graphics";
+import { useState, useCallback, useEffect, useMemo, createContext } from "react";
+import { c as castMapColumnsWidthToRecord } from "../../helpers/castMapColumnsWidthToRecord.js";
+import { useFirstRender, useIsMobile } from "@m4l/graphics";
 import { g as getComponentClasses } from "../../../../utils/getComponentSlotRoot.js";
 import { a as DATAGRID_ROW_HEIGHTS, b as DATAGRID_ROW_HEADER_HEIGHTS, D as DATAGRID_PREFIX_NAME } from "../../constants.js";
 import { C as ControlNavigateSlots, a as ColumnsConfigSlots, T as TextEditorSlots, b as TableSlots, R as RowsCountSlots, A as ActionsSlots, D as DataGridSlots } from "../../slots/DataGridEnum.js";
 import { deepEqual } from "fast-equals";
-import { u as useViewMode } from "../../hooks/useViewMode/useViewMode.js";
-import { u as useRowHeight } from "../../hooks/useRowHeight/useRowHeight.js";
-import { u as useColumnsWidth } from "../../hooks/useColumnsWidth/useColumnsWidth.js";
-import { u as useViewConfig } from "../../hooks/useViewConfig/useViewConfig.js";
-import { u as useChangeColumnsConfig } from "../../hooks/useChangeColumnsConfig/useChangeColumnsConfig.js";
-import { u as useChangeColumnsOrder } from "../../hooks/useChangeColumnsOrder/useChangeColumnsOrder.js";
-import { g as getColumnsWidth } from "../../helpers/getColumnsWidth/getColumnsWidth.js";
-import { g as getInitialColumnsConfig } from "../../helpers/getInitialColumnsConfig/getInitialColumnsConfig.js";
-import { g as getAllViewModes } from "../../helpers/getAllViewModes/getAllViewModes.js";
-import { g as getViewSpecificConfig } from "../../helpers/getViewSpecificConfig/getViewSpecificConfig.js";
-import { g as getViewMode } from "../../helpers/getViewMode/getViewMode.js";
 const DataGridContext = createContext(null);
+function getColumnsWidth(id, columns, defaultUserColumns) {
+  const newMap = /* @__PURE__ */ new Map();
+  let storeColumnsWidth;
+  try {
+    const item = window.localStorage.getItem(`${id}_columns_width`);
+    storeColumnsWidth = item !== null ? new Map(JSON.parse(item)) : /* @__PURE__ */ new Map();
+  } catch (_e) {
+    storeColumnsWidth = /* @__PURE__ */ new Map();
+  }
+  for (let i = 0; i < columns.length; i++) {
+    let width;
+    if (defaultUserColumns) {
+      try {
+        width = defaultUserColumns.columnsWidths[columns[i].key];
+      } catch (_e) {
+      }
+    }
+    if (width === void 0) {
+      const storeWidth = storeColumnsWidth.get(columns[i].key);
+      if (typeof storeWidth === "number") {
+        width = storeWidth;
+      }
+    }
+    if (width !== void 0) {
+      newMap.set(columns[i].key, width);
+    }
+  }
+  return newMap;
+}
+function saveColumnsWidth(id, storeColumnsWidth, onChangeUserColumns) {
+  if (onChangeUserColumns) {
+    const columnsWidthObject = castMapColumnsWidthToRecord(storeColumnsWidth);
+    onChangeUserColumns({
+      reason: "columnsWidths",
+      userConfig: columnsWidthObject
+    });
+    return;
+  }
+  localStorage.setItem(
+    `${id}_columns_width`,
+    JSON.stringify([...storeColumnsWidth])
+  );
+}
+const getAllViewModes = () => {
+  return ["table", "cards"];
+};
+const getViewSpecificConfig = (viewMode) => {
+  const configs = {
+    table: {
+      defaults: { frozen: false },
+      originalDefaults: { originalFrozen: false },
+      dynamicOriginalProperty: (item) => ({
+        originalFrozen: item?.frozen ?? false
+      })
+    },
+    cards: {
+      defaults: { showTitle: true },
+      originalDefaults: { originalShowTitle: true },
+      dynamicOriginalProperty: (item) => ({
+        originalShowTitle: item?.showTitle ?? true
+      })
+    }
+  };
+  return configs[viewMode] || configs.table;
+};
+const getViewSuffix = (viewMode) => {
+  if (viewMode === "table") {
+    return "";
+  }
+  return `_${viewMode}`;
+};
+function getInitialColumnsConfig(id, columns, viewMode, defaultUserConfig, viewSpecificDefaults, originalViewSpecificDefaults) {
+  let columnsConfig;
+  if (defaultUserConfig) {
+    columnsConfig = defaultUserConfig;
+  } else {
+    columnsConfig = loadViewConfig(
+      id,
+      getViewSuffix(viewMode)
+    ) || [];
+  }
+  return columns.map((column, index) => {
+    const existingConfig = columnsConfig.find((c) => c.key === column.key);
+    const columnConfigIndex = existingConfig ? columnsConfig.indexOf(existingConfig) : -1;
+    const baseConfig = {
+      key: column.key,
+      name: typeof column.name === "string" ? column.name : String(column.name),
+      hidden: column.hidden === void 0 ? false : column.hidden,
+      index: columnConfigIndex > -1 ? columnConfigIndex : index,
+      visible: existingConfig?.visible !== void 0 ? existingConfig.visible : column.visible === void 0 ? true : column.visible,
+      originalIndex: index,
+      originalVisible: column.visible === void 0 ? true : column.visible
+    };
+    return {
+      ...baseConfig,
+      ...viewSpecificDefaults,
+      ...originalViewSpecificDefaults,
+      ...existingConfig || {}
+    };
+  }).sort((a, b) => a.index - b.index);
+}
+function saveViewConfig(id, viewSuffix, config, onChangeCallback) {
+  if (onChangeCallback) {
+    const reason = viewSuffix === "" ? "columnsConfig" : `columnsConfig${viewSuffix.replace("_", "")}`;
+    onChangeCallback({
+      reason,
+      userConfig: config
+    });
+    return;
+  }
+  const storageKey = viewSuffix === "" ? `${id}_columns_config` : `${id}_columns_config${viewSuffix}`;
+  localStorage.setItem(storageKey, JSON.stringify(config));
+}
+function loadViewConfig(id, viewSuffix) {
+  try {
+    const storageKey = viewSuffix === "" ? `${id}_columns_config` : `${id}_columns_config${viewSuffix}`;
+    const stored = localStorage.getItem(storageKey);
+    return stored ? JSON.parse(stored) : null;
+  } catch (_e) {
+    return null;
+  }
+}
+function saveViewMode(id, viewMode) {
+  localStorage.setItem(`${id}_view_mode`, viewMode);
+}
+function getIndexRowHeightVariant(variant) {
+  if (variant === "compact") {
+    return 0;
+  }
+  if (variant === "standard") {
+    return 1;
+  }
+  return 2;
+}
 function DataGridProvider(props) {
   const {
     id,
     children,
     columns,
-    defaultConfig,
-    onChangeConfig,
     defaultUserColumns,
-    // deprecated
-    onChangeUserColumns,
-    // deprecated
     rows,
     rowsCount,
     rowActionsGetter,
@@ -38,6 +157,7 @@ function DataGridProvider(props) {
     onCheckedRowsChange,
     checkedRowsMultiple,
     rowKeyGetter,
+    onChangeUserColumns,
     externalSortSettings: sortSettings,
     externalFilterSettings: filterSettings,
     size,
@@ -46,35 +166,8 @@ function DataGridProvider(props) {
     defaultViewMode,
     cardsViewConfig
   } = props;
-  const resolvedDefaultConfig = defaultConfig ?? defaultUserColumns;
-  const resolvedOnChangeConfig = onChangeConfig ?? onChangeUserColumns;
   const isFirstRender = useFirstRender([columns, id]);
-  const { viewModeState, setViewModeState, handleViewModeChange } = useViewMode({
-    id,
-    viewMode,
-    defaultViewMode,
-    onViewModeChange,
-    onChangeConfig: resolvedOnChangeConfig
-  });
-  const { currentRowHeightVariant, setRowHeightVariant } = useRowHeight({
-    rowHeights,
-    rowHeaderHeights,
-    initialRowHeightVariant
-  });
-  const { columnsWidths, setColumnsWidths, onChangeColumnWidth } = useColumnsWidth({
-    id,
-    onChangeConfig: resolvedOnChangeConfig
-  });
-  const { getConfigColumns, updateConfigColumns } = useViewConfig();
-  const { onChangeColumnsConfig } = useChangeColumnsConfig({
-    id,
-    onChangeConfig: resolvedOnChangeConfig,
-    updateConfigColumns
-  });
-  const { onChangeColumnsOrder } = useChangeColumnsOrder({
-    getConfigColumns,
-    onChangeColumnsConfig
-  });
+  const isMobile = useIsMobile();
   const classes = getComponentClasses(DATAGRID_PREFIX_NAME, {
     ...DataGridSlots,
     ...ActionsSlots,
@@ -84,8 +177,80 @@ function DataGridProvider(props) {
     ...ColumnsConfigSlots,
     ...ControlNavigateSlots
   });
+  const [columnsWidths, setColumnsWidths] = useState(/* @__PURE__ */ new Map());
+  const [viewConfig, setViewConfig] = useState(() => ({
+    table: [],
+    cards: []
+  }));
+  const getConfigColumns = useCallback(
+    (viewModeParam) => {
+      return viewConfig[viewModeParam];
+    },
+    [viewConfig]
+  );
+  const updateConfigColumns = useCallback(
+    (viewModeParam, config) => {
+      setViewConfig((prev) => ({
+        ...prev,
+        [viewModeParam]: config
+      }));
+    },
+    []
+  );
   const [rowsFilterCount, setRowFilterCount] = useState(rowsCount);
   const [sortColumns, setSortColumns] = useState([]);
+  const [viewModeState, setViewModeState] = useState(() => {
+    if (viewMode) {
+      return viewMode;
+    }
+    try {
+      const savedViewMode = localStorage.getItem(`${id}_view_mode`);
+      if (savedViewMode === "cards" || savedViewMode === "table") {
+        return savedViewMode;
+      }
+    } catch (_e) {
+    }
+    if (defaultViewMode) {
+      return defaultViewMode;
+    }
+    return isMobile ? "cards" : "table";
+  });
+  const handleViewModeChange = useCallback(
+    (newViewMode) => {
+      setViewModeState(newViewMode);
+      saveViewMode(id, newViewMode);
+      onViewModeChange?.(newViewMode);
+    },
+    [onViewModeChange, id]
+  );
+  useEffect(() => {
+    if (viewMode !== void 0) {
+      setViewModeState(viewMode);
+    }
+  }, [viewMode]);
+  const [currentRowHeightVariant, setCurrentRowHeightVariant] = useState(() => {
+    if (typeof rowHeights !== typeof rowHeaderHeights) {
+      throw new Error("Must be same type rowheights and rowHeaderTypes");
+    }
+    if (typeof rowHeights === "number" && typeof rowHeaderHeights === "number") {
+      return {
+        rowHVariant: "compact",
+        rowHeight: rowHeights,
+        rowHeaderHeight: rowHeaderHeights
+      };
+    }
+    if (typeof rowHeights !== "number" && rowHeights.length !== 3) {
+      throw new Error("Must be 3 heights");
+    }
+    if (typeof rowHeaderHeights !== "number" && rowHeaderHeights.length !== 3) {
+      throw new Error("Must be 3 HeaderHeights");
+    }
+    return {
+      rowHVariant: initialRowHeightVariant,
+      rowHeight: typeof rowHeights !== "number" ? rowHeights[getIndexRowHeightVariant(initialRowHeightVariant)] : rowHeights,
+      rowHeaderHeight: typeof rowHeaderHeights !== "number" ? rowHeaderHeights[getIndexRowHeightVariant(initialRowHeightVariant)] : rowHeaderHeights
+    };
+  });
   useEffect(() => {
     const keys = new Set(columns.map((c) => c.key));
     if (sortSettings?.sortsColumns) {
@@ -151,24 +316,24 @@ function DataGridProvider(props) {
     }
   }, [columns, sortSettings, filterSettings, cardsViewConfig]);
   const finalRowHeights = useMemo(() => rowHeights, [rowHeights]);
+  let timerSaveColumns;
   useEffect(() => {
     if (isFirstRender) {
-      setColumnsWidths(getColumnsWidth(id, columns, resolvedDefaultConfig));
-      setViewModeState(getViewMode(id, resolvedDefaultConfig, defaultViewMode) ?? "table");
+      setColumnsWidths(getColumnsWidth(id, columns, defaultUserColumns));
       updateConfigColumns(
         "table",
         getInitialColumnsConfig(
           id,
           columns,
           "table",
-          resolvedDefaultConfig?.columnsConfig,
+          defaultUserColumns?.columnsConfig,
           { frozen: false },
           { originalFrozen: false }
         )
       );
       const finalCardsConfig = (() => {
-        if (resolvedDefaultConfig?.columnsConfigCards) {
-          return resolvedDefaultConfig.columnsConfigCards;
+        if (defaultUserColumns?.columnsConfigCards) {
+          return defaultUserColumns.columnsConfigCards;
         }
         if (cardsViewConfig?.columnsConfig) {
           return cardsViewConfig.columnsConfig.map((colConfig, index) => {
@@ -197,7 +362,7 @@ function DataGridProvider(props) {
         )
       );
     }
-  }, [resolvedDefaultConfig]);
+  }, [defaultUserColumns]);
   useEffect(() => {
     if (!isFirstRender) {
       const updatedConfigs = {
@@ -286,9 +451,65 @@ function DataGridProvider(props) {
       });
     }
   }, [columns, id]);
+  const onChangeColumnsConfig = useCallback(
+    (viewModeParam, newConfig) => {
+      saveViewConfig(
+        id,
+        getViewSuffix(viewModeParam),
+        newConfig,
+        onChangeUserColumns
+      );
+      updateConfigColumns(viewModeParam, newConfig);
+    },
+    [id, onChangeUserColumns, updateConfigColumns]
+  );
+  const onChangeColumnsOrder = useCallback(
+    (viewModeParam, sourceKey, targetKey) => {
+      if (sourceKey === targetKey) {
+        return;
+      }
+      const currentConfig = getConfigColumns(viewModeParam);
+      const sourceColumnIndex = currentConfig.findIndex(
+        (c) => c.key === sourceKey
+      );
+      const targetColumnIndex = currentConfig.findIndex(
+        (c) => c.key === targetKey
+      );
+      const reorderedConfig = [...currentConfig];
+      reorderedConfig.splice(
+        targetColumnIndex,
+        0,
+        reorderedConfig.splice(sourceColumnIndex, 1)[0]
+      );
+      onChangeColumnsConfig(viewModeParam, reorderedConfig);
+    },
+    [getConfigColumns, onChangeColumnsConfig]
+  );
+  const onChangeColumnWidth = (columnKey, width) => {
+    columnsWidths.set(columnKey, Math.round(width));
+    if (timerSaveColumns) {
+      clearTimeout(timerSaveColumns);
+    }
+    timerSaveColumns = setTimeout(() => {
+      saveColumnsWidth(id, columnsWidths, onChangeUserColumns);
+    }, 500);
+  };
   const setRowFilterCountInternal = (newRowsCount) => {
     setRowFilterCount(newRowsCount);
   };
+  const setCurrentRowHeightInternal = useCallback(
+    (newVariant) => {
+      if (typeof rowHeights === "number" || typeof rowHeaderHeights === "number") {
+        throw new Error("Only use setCurrentRowHeight with vector rowHeights");
+      }
+      setCurrentRowHeightVariant({
+        rowHVariant: newVariant,
+        rowHeight: rowHeights[getIndexRowHeightVariant(newVariant)],
+        rowHeaderHeight: rowHeaderHeights[getIndexRowHeightVariant(newVariant)]
+      });
+    },
+    [setCurrentRowHeightVariant, rowHeights, rowHeaderHeights]
+  );
   return /* @__PURE__ */ jsx(
     DataGridContext.Provider,
     {
@@ -308,13 +529,11 @@ function DataGridProvider(props) {
         onChangeColumnWidth,
         setRowsCount: setRowFilterCountInternal,
         rowActionsGetter,
-        setRowHeightVariant,
+        setRowHeightVariant: setCurrentRowHeightInternal,
         onCheckedRowsChange,
         checkedRowsMultiple,
         rowKeyGetter,
-        onChangeConfig: resolvedOnChangeConfig,
-        onChangeUserColumns: resolvedOnChangeConfig,
-        // deprecated alias
+        onChangeUserColumns,
         sortColumns,
         setSortColumns,
         externalSortSettings: sortSettings,

package/components/DataGrid/contexts/DataGridContext/types.d.ts

@@ -1,14 +1,23 @@
 import { ReactNode } from 'react';
-import { RowKey, RowHeightVariants, GridProps, OnChangeConfig } from '../../types';
+import { RowKey, RowHeightVariants, GridProps } from '../../types';
 import { Maybe } from '@m4l/core';
 import { ActionsSlots, ColumnsConfigSlots, ControlNavigateSlots, DataGridSlots, RowsCountSlots, TableSlots, TextEditorSlots } from '../../slots/DataGridEnum';
 import { SortColumn } from 'react-data-grid';
-import { IGridConfig, BaseViewConfig } from '../../types.helpers';
+/**
+ * Configuración base genérica que puede extenderse con propiedades específicas de cualquier vista
+ * USO INTERNO: El sistema usa esto para manejar genéricamente las configuraciones
+ */
+export type BaseViewConfig<TViewSpecific = {}> = TViewSpecific & {
+    key: string;
+    visible: boolean;
+    index: number;
+    name?: string;
+};
 /**
  * Configuración extendida genérica con propiedades originales
  * USO INTERNO: El contexto usa esto para el estado interno con propiedades de tracking
  */
-export type IViewConfig<TViewSpecific = object, TOriginalViewSpecific = object> = BaseViewConfig<TViewSpecific> & {
+export type IViewConfig<TViewSpecific = {}, TOriginalViewSpecific = {}> = BaseViewConfig<TViewSpecific> & {
     hidden: boolean;
     originalIndex: number;
     originalVisible: boolean;
@@ -53,6 +62,15 @@ export interface IConfigColumnCards extends Omit<IConfigColumn, 'frozen' | 'orig
     originalShowTitle: boolean;
 }
 export type ViewMode = 'table' | 'cards';
+/**
+ * Configuración base del Grid (API pública original)
+ * USO: Tipo base para defaultUserColumns - mantiene retrocompatibilidad
+ * IMPORTANTE: No modificar para mantener retrocompatibilidad con código existente
+ */
+export interface IGridConfig {
+    columnsConfig: BaseConfigColumn[];
+    columnsWidths: Record<RowKey, number>;
+}
 /**
  * Configuración extendida del Grid para soportar múltiples vistas
  * USO: Para nuevas implementaciones que soporten cards y futuras vistas
@@ -60,40 +78,21 @@ export type ViewMode = 'table' | 'cards';
  */
 export interface IGridConfigExtended extends IGridConfig {
     columnsConfigCards?: BaseConfigColumnCards[];
-    viewMode?: ViewMode;
 }
-export interface DataGridProviderProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Pick<GridProps<TRow, TSummaryRow, TKey>, 'rows' | 'columns' | 'rowActionsGetter' | 'rowHeaderHeights' | 'rowHeights' | 'initialRowHeightVariant' | 'checkedRows' | 'onCheckedRowsChange' | 'checkedRowsMultiple' | 'rowKeyGetter' | 'externalSortSettings' | 'externalFilterSettings' | 'defaultViewMode' | 'cardsViewConfig'> {
+export interface DataGridProviderProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Pick<GridProps<TRow, TSummaryRow, TKey>, 'rows' | 'columns' | 'rowActionsGetter' | 'rowHeaderHeights' | 'rowHeights' | 'initialRowHeightVariant' | 'checkedRows' | 'onCheckedRowsChange' | 'checkedRowsMultiple' | 'rowKeyGetter' | 'onChangeUserColumns' | 'defaultUserColumns' | 'externalSortSettings' | 'externalFilterSettings' | 'defaultViewMode' | 'cardsViewConfig'> {
     id: number | string;
     children: ReactNode;
     rowsCount: number;
     size: GridProps<any, any, any>['size'];
     viewMode?: ViewMode;
     onViewModeChange?: (viewMode: ViewMode) => void;
-    /** Configuración inicial del DataGrid */
-    defaultConfig?: IGridConfigExtended;
-    /** Callback para persistir cambios de configuración */
-    onChangeConfig?: OnChangeConfig;
-    /**
-     * @deprecated Usar `defaultConfig` en su lugar.
-     */
-    defaultUserColumns?: IGridConfigExtended;
-    /**
-     * @deprecated Usar `onChangeConfig` en su lugar.
-     */
-    onChangeUserColumns?: OnChangeConfig;
 }
 export type RowHeightState = {
     rowHVariant: RowHeightVariants;
     rowHeight: number;
     rowHeaderHeight: number;
 };
-export interface DataGridContextProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Pick<DataGridProviderProps<TRow, TSummaryRow, TKey>, 'rows' | 'checkedRows' | 'onCheckedRowsChange' | 'checkedRowsMultiple' | 'rowHeights' | 'rowsCount' | 'rowActionsGetter' | 'rowKeyGetter' | 'externalSortSettings' | 'externalFilterSettings' | 'viewMode' | 'onViewModeChange' | 'defaultViewMode' | 'cardsViewConfig'> {
-    /** Callback para persistir cambios de configuración */
-    onChangeConfig?: OnChangeConfig;
-    /**
-     * @deprecated Usar `onChangeConfig` en su lugar.
-     */
-    onChangeUserColumns?: OnChangeConfig;
+export interface DataGridContextProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> extends Pick<DataGridProviderProps<TRow, TSummaryRow, TKey>, 'rows' | 'checkedRows' | 'onCheckedRowsChange' | 'checkedRowsMultiple' | 'rowHeights' | 'rowsCount' | 'rowActionsGetter' | 'rowKeyGetter' | 'onChangeUserColumns' | 'externalSortSettings' | 'externalFilterSettings' | 'viewMode' | 'onViewModeChange' | 'defaultViewMode' | 'cardsViewConfig'> {
     getConfigColumns: (viewMode: ViewMode) => IViewConfig[];
     onChangeColumnsConfig: (viewMode: ViewMode, config: IViewConfig[]) => void;
     onChangeColumnsOrder: (viewMode: ViewMode, sourceKey: string, targetKey: string) => void;

package/components/DataGrid/index.d.ts

@@ -1,10 +1,9 @@
 export { DataGrid } from './DataGrid';
 export * from './formatters';
-export type { Column, RenderEditCellProps, RenderCellProps, } from 'react-data-grid';
-export type { RowKey, ChangeConfig, ChangeUserColumn, RowActionsGetter, RowKeyGetter, } from './types';
+export type { Column, RenderEditCellProps, RenderCellProps } from 'react-data-grid';
+export type { RowKey, ChangeUserColumn, RowActionsGetter, RowKeyGetter } from './types';
 export { getDataGridComponentsDictionary } from './dictionary';
 export { TextEditor, NumberEditor } from './subcomponents/editors/TextEditor';
 export { getDataGridRowsFromSet } from './utils/getDataGridRowsFromSet';
-export type { IGridConfigExtended, BaseConfigColumn, } from './contexts/DataGridContext/types';
-export { DATAGRID_SEMANTIC_WIDTHS, DATAGRID_ROW_HEADER_HEIGHTS, DATAGRID_ROW_HEIGHTS, } from './constants';
-export * from './types.helpers';
+export type { IGridConfig, IGridConfigExtended, BaseConfigColumn } from './contexts/DataGridContext/types';
+export { DATAGRID_SEMANTIC_WIDTHS, DATAGRID_ROW_HEADER_HEIGHTS, DATAGRID_ROW_HEIGHTS } from './constants';

package/components/DataGrid/types.d.ts

@@ -61,27 +61,12 @@ export interface ColumnConfig {
     position?: number;
     frozen?: Maybe<boolean>;
 }
-type KeyConfig = keyof IGridConfigExtended;
-/**
- * Tipo que representa un cambio de configuración del DataGrid.
- */
-export interface ChangeConfig<T extends KeyConfig = KeyConfig> {
+type KeyUserColumns = keyof IGridConfigExtended;
+export interface ChangeUserColumn<T extends KeyUserColumns = KeyUserColumns> {
     reason: T;
     userConfig: IGridConfigExtended[T];
 }
-/**
- * @deprecated Usar `ChangeConfig` en su lugar. Este tipo será eliminado en futuras versiones.
- */
-export type ChangeUserColumn = ChangeConfig;
-/**
- * Callback que se ejecuta cuando cambia cualquier configuración del DataGrid.
- * Maneja todas las vistas genéricamente a través de IGridConfigExtended.
- */
-export type OnChangeConfig = (props: ChangeConfig) => void;
-/**
- * @deprecated Usar `OnChangeConfig` en su lugar. Este tipo será eliminado en futuras versiones.
- */
-export type OnChangeUserColumns = OnChangeConfig;
+export type OnChangeUserColumns = (props: ChangeUserColumn) => void;
 export type SortApplied = {
     columnKey: string;
     removable: boolean;
@@ -161,21 +146,12 @@ export interface GridProps<TRow, TSummaryRow, TKey extends RowKey = RowKey> exte
     checkedRowsMultiple?: boolean;
     onRowsChange?: Maybe<(rows: TRow[], data: RowsChangeData<TRow, TSummaryRow>) => void>;
     /**
-     * Configuración inicial del DataGrid (anchos, orden, visibilidad, viewMode).
-     * Tiene prioridad sobre localStorage.
-     */
-    defaultConfig?: IGridConfigExtended;
-    /**
-     * Callback que se ejecuta cuando cambia cualquier configuración del DataGrid.
-     * @param props - Objeto con `reason` (tipo de cambio) y `userConfig` (nueva configuración)
-     */
-    onChangeConfig?: OnChangeConfig;
-    /**
-     * @deprecated Usar `defaultConfig` en su lugar. Esta prop será eliminada en futuras versiones.
+     * Propiedad opcional que recibe la configuración de las columnas
      */
     defaultUserColumns?: IGridConfigExtended;
     /**
-     * @deprecated Usar `onChangeConfig` en su lugar. Esta prop será eliminada en futuras versiones.
+     * Propiedad que recibe la función que se ejecuta cuando se cambian
+     * las configuraciones de las columnas.
      */
     onChangeUserColumns?: OnChangeUserColumns;
     /**