@m4l/components 9.3.34 → 9.3.35-JT27112025.beta.1

package/components/DataGrid/hooks/useChangeColumnsConfig/index.js

@@ -0,0 +1 @@
+

package/components/DataGrid/hooks/useChangeColumnsConfig/useChangeColumnsConfig.d.ts

@@ -0,0 +1,9 @@
+import { UseChangeColumnsConfigParams, UseChangeColumnsConfigReturn } from '../../types.hooks';
+/**
+ * Hook para manejar el cambio de configuración de columnas.
+ *
+ * Guarda la configuración en localStorage y actualiza el estado.
+ * @param params - Parámetros del hook
+ * @returns Función para cambiar la configuración de columnas
+ */
+export declare const useChangeColumnsConfig: ({ id, onChangeUserColumns, updateConfigColumns, }: UseChangeColumnsConfigParams) => UseChangeColumnsConfigReturn;

package/components/DataGrid/hooks/useChangeColumnsConfig/useChangeColumnsConfig.js

@@ -0,0 +1,27 @@
+import { useCallback } from "react";
+import { s as saveViewConfig } from "../../helpers/saveViewConfig/saveViewConfig.js";
+import { g as getViewSuffix } from "../../helpers/getViewSuffix/getViewSuffix.js";
+const useChangeColumnsConfig = ({
+  id,
+  onChangeUserColumns,
+  updateConfigColumns
+}) => {
+  const onChangeColumnsConfig = useCallback(
+    (viewModeParam, newConfig) => {
+      saveViewConfig(
+        id,
+        getViewSuffix(viewModeParam),
+        newConfig,
+        onChangeUserColumns
+      );
+      updateConfigColumns(viewModeParam, newConfig);
+    },
+    [id, onChangeUserColumns, updateConfigColumns]
+  );
+  return {
+    onChangeColumnsConfig
+  };
+};
+export {
+  useChangeColumnsConfig as u
+};

package/components/DataGrid/hooks/useChangeColumnsConfig/useChangeColumnsConfig.test.d.ts

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

package/components/DataGrid/hooks/useChangeColumnsOrder/index.d.ts

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

package/components/DataGrid/hooks/useChangeColumnsOrder/index.js

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,10 @@
+import { UseChangeColumnsOrderParams, UseChangeColumnsOrderReturn } from '../../types.hooks';
+/**
+ * Hook para manejar el cambio de orden de columnas.
+ *
+ * Reordena las columnas y llama a onChangeColumnsConfig para persistir.
+ * @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
+ */
+export declare const useChangeColumnsOrder: ({ getConfigColumns, onChangeColumnsConfig, }: UseChangeColumnsOrderParams) => UseChangeColumnsOrderReturn;

package/components/DataGrid/hooks/useChangeColumnsOrder/useChangeColumnsOrder.js

@@ -0,0 +1,34 @@
+import { useCallback } from "react";
+const useChangeColumnsOrder = ({
+  getConfigColumns,
+  onChangeColumnsConfig
+}) => {
+  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]
+  );
+  return {
+    onChangeColumnsOrder
+  };
+};
+export {
+  useChangeColumnsOrder as u
+};

package/components/DataGrid/hooks/useChangeColumnsOrder/useChangeColumnsOrder.test.d.ts

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

package/components/DataGrid/hooks/useColumnsWidth/index.d.ts

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

package/components/DataGrid/hooks/useColumnsWidth/index.js

@@ -0,0 +1 @@
+

package/components/DataGrid/hooks/useColumnsWidth/useColumnsWidth.d.ts

@@ -0,0 +1,11 @@
+import { UseColumnsWidthParams, UseColumnsWidthReturn } from '../../types.hooks';
+/**
+ * Hook para manejar el estado del ancho de las columnas del DataGrid.
+ *
+ * Maneja:
+ * - Estado del ancho de cada columna
+ * - Guardado con debounce de 500ms al cambiar el ancho
+ * @param params - Parámetros del hook
+ * @returns Estado y función para cambiar el ancho de columnas
+ */
+export declare const useColumnsWidth: ({ id, onChangeUserColumns, }: UseColumnsWidthParams) => UseColumnsWidthReturn;

package/components/DataGrid/hooks/useColumnsWidth/useColumnsWidth.js

@@ -0,0 +1,29 @@
+import { useState, useRef, useCallback } from "react";
+import { s as saveColumnsWidth } from "../../helpers/saveColumnsWidth/saveColumnsWidth.js";
+const useColumnsWidth = ({
+  id,
+  onChangeUserColumns
+}) => {
+  const [columnsWidths, setColumnsWidths] = useState(/* @__PURE__ */ new Map());
+  const timerRef = useRef(null);
+  const onChangeColumnWidth = useCallback(
+    (columnKey, width) => {
+      columnsWidths.set(columnKey, Math.round(width));
+      if (timerRef.current) {
+        clearTimeout(timerRef.current);
+      }
+      timerRef.current = setTimeout(() => {
+        saveColumnsWidth(id, columnsWidths, onChangeUserColumns);
+      }, 500);
+    },
+    [id, columnsWidths, onChangeUserColumns]
+  );
+  return {
+    columnsWidths,
+    setColumnsWidths,
+    onChangeColumnWidth
+  };
+};
+export {
+  useColumnsWidth as u
+};

package/components/DataGrid/hooks/useColumnsWidth/useColumnsWidth.test.d.ts

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

package/components/DataGrid/hooks/useRowHeight/index.d.ts

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

package/components/DataGrid/hooks/useRowHeight/index.js

@@ -0,0 +1 @@
+

package/components/DataGrid/hooks/useRowHeight/useRowHeight.d.ts

@@ -0,0 +1,28 @@
+import { UseRowHeightParams, UseRowHeightReturn } from '../../types.hooks';
+/**
+ * Hook para manejar el estado de la altura de las filas del DataGrid.
+ *
+ * Soporta dos modos:
+ * - **Modo fijo**: rowHeights y rowHeaderHeights son números fijos
+ * - **Modo variable**: rowHeights y rowHeaderHeights son arrays de 3 elementos [compact, standard, confortable]
+ * @param params - Parámetros del hook
+ * @returns Estado actual y función para cambiar el variant
+ * @throws Error si rowHeights y rowHeaderHeights no son del mismo tipo
+ * @throws Error si los arrays no tienen exactamente 3 elementos
+ * @throws Error si se intenta cambiar el variant en modo fijo
+ * @example
+ * // Modo variable (permite cambiar variant)
+ * const { currentRowHeightVariant, setRowHeightVariant } = useRowHeight({
+ *   rowHeights: [32, 40, 48],
+ *   rowHeaderHeights: [36, 44, 52],
+ *   initialRowHeightVariant: 'standard',
+ * });
+ *
+ * // Modo fijo (altura constante)
+ * const { currentRowHeightVariant } = useRowHeight({
+ *   rowHeights: 40,
+ *   rowHeaderHeights: 44,
+ *   initialRowHeightVariant: 'standard',
+ * });
+ */
+export declare const useRowHeight: ({ rowHeights, rowHeaderHeights, initialRowHeightVariant, }: UseRowHeightParams) => UseRowHeightReturn;

package/components/DataGrid/hooks/useRowHeight/useRowHeight.js

@@ -0,0 +1,51 @@
+import { useState, useCallback } from "react";
+import { g as getIndexRowHeightVariant } from "../../helpers/getIndexRowHeightVariant/getIndexRowHeightVariant.js";
+const useRowHeight = ({
+  rowHeights,
+  rowHeaderHeights,
+  initialRowHeightVariant
+}) => {
+  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
+    };
+  });
+  const setRowHeightVariant = 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)]
+      });
+    },
+    [rowHeights, rowHeaderHeights]
+  );
+  return {
+    currentRowHeightVariant,
+    setRowHeightVariant
+  };
+};
+export {
+  useRowHeight as u
+};

package/components/DataGrid/hooks/useRowHeight/useRowHeight.test.d.ts

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

package/components/DataGrid/hooks/useViewConfig/index.d.ts

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

package/components/DataGrid/hooks/useViewConfig/index.js

@@ -0,0 +1 @@
+

package/components/DataGrid/hooks/useViewConfig/useViewConfig.d.ts

@@ -0,0 +1,9 @@
+import { UseViewConfigReturn } from '../../types.hooks';
+/**
+ * Hook para manejar el estado de la configuración de columnas por vista.
+ *
+ * Maneja un estado genérico unificado para las configuraciones de TODAS las vistas
+ * (table, cards, etc).
+ * @returns Estado y funciones para manejar la configuración de vistas
+ */
+export declare const useViewConfig: () => UseViewConfigReturn;

package/components/DataGrid/hooks/useViewConfig/useViewConfig.js

@@ -0,0 +1,30 @@
+import { useState, useCallback } from "react";
+const useViewConfig = () => {
+  const [viewConfig, setViewConfig] = useState(() => ({
+    table: [],
+    cards: []
+  }));
+  const getConfigColumns = useCallback(
+    (viewModeParam) => {
+      return viewConfig[viewModeParam];
+    },
+    [viewConfig]
+  );
+  const updateConfigColumns = useCallback(
+    (viewModeParam, config) => {
+      setViewConfig((prev) => ({
+        ...prev,
+        [viewModeParam]: config
+      }));
+    },
+    []
+  );
+  return {
+    viewConfig,
+    getConfigColumns,
+    updateConfigColumns
+  };
+};
+export {
+  useViewConfig as u
+};

package/components/DataGrid/hooks/useViewConfig/useViewConfig.test.d.ts

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

package/components/DataGrid/hooks/useViewMode/index.d.ts

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

package/components/DataGrid/hooks/useViewMode/index.js

@@ -0,0 +1 @@
+

package/components/DataGrid/hooks/useViewMode/useViewMode.d.ts

@@ -0,0 +1,44 @@
+import { UseViewModeParams, UseViewModeReturn } from '../../types.hooks';
+/**
+ * Hook para manejar el estado del modo de visualización (table/cards).
+ *
+ * ## Precedencia para determinar el viewMode inicial
+ *
+ * 1. `viewMode` prop - Modo controlado (el padre controla completamente el estado)
+ * 2. localStorage - Preferencia del usuario guardada previamente
+ * 3. `defaultViewMode` prop - Valor inicial establecido por el desarrollador
+ * 4. `useIsMobile()` - Fallback automático según el dispositivo:
+ *    - Móvil: 'cards'
+ *    - Escritorio: 'table'
+ *
+ * ## Persistencia del viewMode
+ *
+ * - Si `onChangeUserColumns` está definido → Guarda en backend (cookies de red)
+ * - Si no está definido → Fallback a localStorage
+ *
+ * ## Modo controlado vs no controlado
+ *
+ * - **Controlado**: Cuando se pasa `viewMode` prop, el padre controla el estado
+ * - **No controlado**: El hook maneja internamente el estado y persiste
+ * @param id - Identificador único del DataGrid
+ * @param viewMode - ViewMode controlado por el padre (opcional)
+ * @param defaultViewMode - ViewMode por defecto cuando no hay valor guardado (opcional)
+ * @param onViewModeChange - Callback cuando cambia el viewMode (opcional)
+ * @param onChangeUserColumns - Callback para guardar en backend (opcional)
+ * @returns viewModeState - Estado actual del viewMode
+ * @returns handleViewModeChange - Función para cambiar el viewMode
+ * @example
+ * // Con persistencia en backend
+ * const { viewModeState, handleViewModeChange } = useViewMode({
+ *   id: 'my-grid',
+ *   defaultViewMode: 'table',
+ *   onChangeUserColumns, // Guarda en backend
+ * });
+ *
+ * // Sin backend (solo localStorage)
+ * const { viewModeState, handleViewModeChange } = useViewMode({
+ *   id: 'my-grid',
+ *   defaultViewMode: 'table',
+ * });
+ */
+export declare const useViewMode: ({ id, viewMode, defaultViewMode, onViewModeChange, onChangeUserColumns, }: UseViewModeParams) => UseViewModeReturn;

package/components/DataGrid/hooks/useViewMode/useViewMode.js

@@ -0,0 +1,48 @@
+import { useState, useCallback, useEffect } from "react";
+import { useIsMobile } from "@m4l/graphics";
+import { s as saveViewMode } from "../../helpers/saveViewMode/saveViewMode.js";
+const useViewMode = ({
+  id,
+  viewMode,
+  defaultViewMode,
+  onViewModeChange,
+  onChangeUserColumns
+}) => {
+  const isMobile = useIsMobile();
+  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, onChangeUserColumns);
+      onViewModeChange?.(newViewMode);
+    },
+    [id, onViewModeChange, onChangeUserColumns]
+  );
+  useEffect(() => {
+    if (viewMode !== void 0) {
+      setViewModeState(viewMode);
+    }
+  }, [viewMode]);
+  return {
+    viewModeState,
+    handleViewModeChange
+  };
+};
+export {
+  useViewMode as u
+};

package/components/DataGrid/hooks/useViewMode/useViewMode.test.d.ts

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

package/components/DataGrid/index.d.ts

@@ -1,9 +1,10 @@
 export { DataGrid } from './DataGrid';
 export * from './formatters';
-export type { Column, RenderEditCellProps, RenderCellProps } from 'react-data-grid';
-export type { RowKey, 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 { IGridConfig, IGridConfigExtended, BaseConfigColumn } from './contexts/DataGridContext/types';
-export { DATAGRID_SEMANTIC_WIDTHS, DATAGRID_ROW_HEADER_HEIGHTS, DATAGRID_ROW_HEIGHTS } from './constants';
+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';

package/components/DataGrid/subcomponents/Cards/helpers/scrollToCardElement.js

@@ -13,8 +13,8 @@ function scrollToCardElement(containerElement, rowKey, selectorType = "data-attr
       return;
     }
     foundElement.scrollIntoView({
-      behavior: "auto",
-      block: "center"
+      behavior: "smooth",
+      block: "end"
     });
   } catch (error) {
     console.error("scrollToCardElement: Error al hacer scroll", error);

package/components/DataGrid/subcomponents/Cards/index.js

@@ -21,6 +21,7 @@ function Cards(props) {
     onCheckedRowsChange
   } = props;
   const containerRef = useRef(null);
+  const hasScrolledToFocusRow = useRef(false);
   const processedColumns = useProcessedColumns(columns);
   const allProcessedColumns = useProcessedColumns(columns, {
     applyVisibilityFilter: false
@@ -31,13 +32,21 @@ function Cards(props) {
     onRowsChange
   });
   const cardHeight = useMemo(() => {
+    const imageHeight = processedColumns.reduce((totalHeight, col) => {
+      const formatterHeight = col.renderCell?.__imageFormatterHeight;
+      return formatterHeight ? totalHeight + formatterHeight : totalHeight;
+    }, 0);
     return calculateCardHeight({
       visibleColumnsCount: processedColumns.length,
       customMinHeight: cardsViewConfig?.customRender?.minHeight
-    });
-  }, [processedColumns.length, cardsViewConfig]);
+    }) + imageHeight;
+  }, [processedColumns, cardsViewConfig]);
   useEffect(() => {
     if (!focusOnRowKey) {
+      hasScrolledToFocusRow.current = false;
+      return;
+    }
+    if (hasScrolledToFocusRow.current) {
       return;
     }
     const rowIndex = rows.findIndex(
@@ -58,9 +67,13 @@ function Cards(props) {
         "data-attribute",
         "data-row-key"
       );
+      if (onSelectedRowsChange) {
+        onSelectedRowsChange(/* @__PURE__ */ new Set([focusOnRowKey]));
+      }
+      hasScrolledToFocusRow.current = true;
     }, 300);
     return () => clearTimeout(timer);
-  }, [focusOnRowKey, rows, rowKeyGetter, cardHeight]);
+  }, [focusOnRowKey, rows, rowKeyGetter, cardHeight, onSelectedRowsChange]);
   if (processedColumns.length === 0) {
     return null;
   }

package/components/DataGrid/subcomponents/Cards/subcomponents/CardRow/index.js

@@ -88,6 +88,7 @@ function CardRowComponent({
           },
           onClick: onCardClick,
           "data-testid": "data-grid-card",
+          "data-row-key": rowKeyGetter(row),
           children: content
         }
       )

package/components/DataGrid/subcomponents/Table/index.js

@@ -68,6 +68,7 @@ function Table(props) {
     anchorEl: null,
     columnKey: null
   });
+  const hasScrolledToFocusRow = useRef(false);
   const [allowSortChange, setAllowSortChange] = useState(false);
   const handleSortColumnsChange = (newSortColumns) => {
     if (allowSortChange) {
@@ -113,6 +114,10 @@ function Table(props) {
   }, [finalRows]);
   useEffect(() => {
     if (!focusOnRowKey) {
+      hasScrolledToFocusRow.current = false;
+      return;
+    }
+    if (hasScrolledToFocusRow.current) {
       return;
     }
     const rowIndex = finalRows.findIndex(
@@ -120,8 +125,12 @@ function Table(props) {
     );
     if (rowIndex !== -1) {
       ref_data_grid.current?.scrollToCell({ rowIdx: rowIndex });
+      if (onSelectedRowsChange) {
+        onSelectedRowsChange(/* @__PURE__ */ new Set([focusOnRowKey]));
+      }
+      hasScrolledToFocusRow.current = true;
     }
-  }, [focusOnRowKey, finalRows, rowKeyGetter]);
+  }, [focusOnRowKey, finalRows, rowKeyGetter, onSelectedRowsChange]);
   const onColumnResize = (idx, width) => {
     onChangeColumnWidth(finalColumns[idx].key, width);
   };

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

@@ -20,6 +20,12 @@ export interface SeedProps {
     withCesar?: boolean;
     withChipStatus?: boolean;
     withTags?: boolean;
+    withImage?: boolean;
+    withImageCustomSize?: {
+        width: number;
+        height: number;
+    };
+    withImageWithoutText?: boolean;
     withActions?: boolean;
     withActionsUser?: boolean;
     withBooleanStatus?: boolean;
@@ -69,6 +75,10 @@ export interface RowType {
         currentStatus: 'superadmin' | 'admin' | 'user';
     };
     color?: string;
+    image?: {
+        url: string;
+        text?: string;
+    };
 }
 interface RangesUncertainty {
     cmcMin: number;

package/components/DataGrid/types.helpers.d.ts

@@ -0,0 +1,55 @@
+import { RowKey } from './types';
+import { BaseConfigColumn } from './contexts/DataGridContext/types';
+/**
+ * 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
+ * de columnas sin importar el tipo de vista (table, cards, etc).
+ * @example
+ * // Para vista table
+ * BaseViewConfig<{ frozen: boolean }>
+ *
+ * // Para vista cards
+ * BaseViewConfig<{ showTitle: boolean }>
+ */
+export type BaseViewConfig<TViewSpecific = object> = TViewSpecific & {
+    key: string;
+    visible: boolean;
+    index: number;
+    name?: string;
+};
+/**
+ *
+ *Este tipo define la estructura de configuración que el usuario puede
+ *pasar al DataGrid para personalizar columnas y sus anchos.
+ *
+ *- `columnsConfig`: Configuración de visibilidad y orden de columnas para vista table
+ *- `columnsWidths`: Anchos personalizados de columnas
+ * @example
+ * ```typescript
+ * const userConfig: IGridConfig = {
+ *   columnsConfig: [
+ *     { key: 'name', visible: true, index: 0, frozen: false },
+ *     { key: 'email', visible: true, index: 1, frozen: false },
+ *   ],
+ *   columnsWidths: { name: 200, email: 300 }
+ * };
+ * ```
+ */
+export interface IGridConfig {
+    /** Configuración de columnas para vista table (visibilidad, orden, frozen) */
+    columnsConfig: BaseConfigColumn[];
+    /** Anchos de columnas en píxeles */
+    columnsWidths: Record<RowKey, number>;
+}
+/**
+ * Configuración específica retornada por getViewSpecificConfig
+ */
+export interface ViewSpecificConfig {
+    /** Valores por defecto para propiedades específicas de la vista */
+    defaults: Record<string, unknown>;
+    /** Valores originales por defecto para tracking de cambios */
+    originalDefaults: Record<string, unknown>;
+    /** Función para obtener propiedades originales dinámicas de un item */
+    dynamicOriginalProperty: (item: unknown) => Record<string, unknown>;
+}

package/components/DataGrid/types.helpers.js

@@ -0,0 +1 @@
+