@m4l/components 7.0.0 → 7.1.2

package/components/CommonActions/components/ActionFormCancel/index.js

@@ -0,0 +1,56 @@
+import { jsx } from "react/jsx-runtime";
+import { useFormContext, useFormState } from "react-hook-form";
+import { useModuleDictionary } from "@m4l/core";
+import { B as Button } from "../../../mui_extended/Button/Button.js";
+import { useCallback, useEffect } from "react";
+import { u as useModal } from "../../../../hooks/useModal/index.js";
+import { u as useCommonActionsUtilityClasses } from "../../classes/index.js";
+import { u as useWindowToolsMF } from "../../../areas/hooks/useWindowToolsMF/index.js";
+import { W as WindowConfirm } from "../../../modal/WindowConfirm/index.js";
+function ActionFormCancel() {
+  const { getLabel } = useModuleDictionary();
+  const { openModal } = useModal();
+  const { close: closeWindow, setFnQueryClose: setQueryClose } = useWindowToolsMF();
+  const { control } = useFormContext();
+  const { isDirty } = useFormState({
+    control
+  });
+  const onConfirmQuit = useCallback(() => {
+    closeWindow();
+  }, []);
+  const onClickCancel = useCallback(() => {
+    if (isDirty) {
+      openModal({
+        window: /* @__PURE__ */ jsx(
+          WindowConfirm,
+          {
+            variant: "warning",
+            title: getLabel("common_actions.confirm_quit_title"),
+            msg: getLabel("common_actions.confirm_quit_msg"),
+            onClickIntro: onConfirmQuit
+          }
+        ),
+        variant: "warning"
+      });
+    } else {
+      onConfirmQuit();
+    }
+  }, [getLabel, isDirty, openModal]);
+  useEffect(() => {
+    setQueryClose(onClickCancel);
+  }, [onClickCancel]);
+  const classes = useCommonActionsUtilityClasses();
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      variant: "outlined",
+      color: "inherit",
+      onClick: onClickCancel,
+      className: classes.actionFormCancel,
+      children: getLabel("common_actions.cancel")
+    }
+  );
+}
+export {
+  ActionFormCancel as A
+};

package/components/CommonActions/components/ActionFormCancel/types.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from '@mui/material';
+import { NavigateOptions, To } from 'react-router-dom';
+export interface ActionFormCancelProps extends ButtonProps {
+    to: To;
+    navigateOptions?: NavigateOptions;
+}

package/components/CommonActions/components/ActionFormIntro/index.d.ts

@@ -1,2 +1,5 @@
 import { MuiLabLoadingButtonProps } from '../../../mui_extended/LoadingButton/types';
+/**
+ * TODO: Documentar
+ */
 export declare function ActionFormIntro(props: MuiLabLoadingButtonProps): import("react/jsx-runtime").JSX.Element;

package/components/CommonActions/components/ActionFormIntro/index.js

@@ -0,0 +1,33 @@
+import { jsx } from "react/jsx-runtime";
+import { useFormContext, useFormState } from "react-hook-form";
+import { useModuleDictionary, useModuleSkeleton } from "@m4l/core";
+import { Skeleton } from "@mui/material";
+import { L as LoadingButton } from "../../../mui_extended/LoadingButton/index.js";
+import { u as useCommonActionsUtilityClasses } from "../../classes/index.js";
+function ActionFormIntro(props) {
+  const { getLabel } = useModuleDictionary();
+  const isSkeleton = useModuleSkeleton();
+  const { control } = useFormContext();
+  const { isSubmitting } = useFormState({
+    control
+  });
+  const classes = useCommonActionsUtilityClasses();
+  if (isSkeleton) {
+    return /* @__PURE__ */ jsx(Skeleton, { variant: "text", width: 57, height: 30 });
+  }
+  return /* @__PURE__ */ jsx(
+    LoadingButton,
+    {
+      variant: "contained",
+      type: "submit",
+      color: "primary",
+      loading: isSubmitting,
+      className: classes.actionFormIntro,
+      ...props,
+      children: getLabel("common_actions.intro")
+    }
+  );
+}
+export {
+  ActionFormIntro as A
+};

package/components/CommonActions/components/ActionIntro/index.d.ts

@@ -1,2 +1,5 @@
 import { ButtonProps } from '../../../mui_extended/Button';
+/**
+ * TODO: Documentar
+ */
 export declare const ActionIntro: (props: ButtonProps) => import("react/jsx-runtime").JSX.Element;

package/components/CommonActions/components/ActionIntro/index.js

@@ -0,0 +1,25 @@
+import { jsx } from "react/jsx-runtime";
+import { useModuleDictionary } from "@m4l/core";
+import { B as Button } from "../../../mui_extended/Button/Button.js";
+import { T as TEST_PROP_ID } from "../../../../test/constants_no_mock.js";
+import { A as ACTIONINTRO_TEST_ID } from "./test/contants.js";
+import { u as useCommonActionsUtilityClasses } from "../../classes/index.js";
+const ActionIntro = (props) => {
+  const { getLabel } = useModuleDictionary();
+  const classes = useCommonActionsUtilityClasses();
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      ...process.env.NODE_ENV !== "production" ? { [TEST_PROP_ID]: ACTIONINTRO_TEST_ID } : {},
+      variant: "contained",
+      type: "submit",
+      color: "primary",
+      className: classes.actionIntro,
+      ...props,
+      children: getLabel("common_actions.intro")
+    }
+  );
+};
+export {
+  ActionIntro as A
+};

package/components/CommonActions/components/ActionIntro/test/contants.js

@@ -0,0 +1,4 @@
+const ACTIONINTRO_TEST_ID = "m4lactions";
+export {
+  ACTIONINTRO_TEST_ID as A
+};

package/components/CommonActions/components/Actions/index.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
-import type { CommonActionsProps } from './types';
-export declare const Actions: import("react").ForwardRefExoticComponent<CommonActionsProps & import("react").RefAttributes<any>>;
+import { CommonActionsProps } from './types';
+export declare const Actions: import('react').ForwardRefExoticComponent<CommonActionsProps & import('react').RefAttributes<any>>;

package/components/CommonActions/components/Actions/index.js

@@ -0,0 +1,24 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import clsx from "clsx";
+import { T as TEST_PROP_ID } from "../../../../test/constants_no_mock.js";
+import { u as useCommonActionsUtilityClasses } from "../../classes/index.js";
+import { W as WrapperStandarActions } from "./styles.js";
+import { g as getNameCommonActionsDataTestId } from "../../tests/utils.js";
+const Actions = forwardRef(function ActionsForwarded(props, ref) {
+  const { children, ...restProps } = props;
+  const classes = useCommonActionsUtilityClasses();
+  return /* @__PURE__ */ jsx(
+    WrapperStandarActions,
+    {
+      ...restProps,
+      ref,
+      className: clsx(classes.root, restProps?.className),
+      ...process.env.NODE_ENV !== "production" ? { [TEST_PROP_ID]: getNameCommonActionsDataTestId("root") } : {},
+      children
+    }
+  );
+});
+export {
+  Actions as A
+};

package/components/CommonActions/components/Actions/styles.d.ts

@@ -1,2 +1 @@
-/// <reference types="react" />
-export declare const WrapperStandarActions: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const WrapperStandarActions: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material/styles').Theme>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/components/CommonActions/components/Actions/styles.js

@@ -0,0 +1,14 @@
+import { styled } from "@mui/material/styles";
+const WrapperStandarActions = styled("div")(({ theme }) => ({
+  // paddingTop: theme.spacing(3),
+  // display: 'flex',
+  // flexDirection: 'row',
+  // justifyContent: 'flex-end',
+  // '& > button': {
+  //     marginLeft: '10px',
+  // },
+  ...theme.components?.M4LCommonActions?.styleOverrides || {}
+}));
+export {
+  WrapperStandarActions as W
+};

package/components/CommonActions/dictionary.d.ts

@@ -1,3 +1,3 @@
-import type { Dictionary } from '@m4l/core';
+import { Dictionary } from '@m4l/core';
 export declare function getCommonActionsDictionary(): string[];
 export declare const defaultCommonActionsDictionary: Dictionary;

package/components/CommonActions/dictionary.js

@@ -0,0 +1,15 @@
+function getCommonActionsDictionary() {
+  return ["common_actions"];
+}
+const defaultCommonActionsDictionary = {
+  common_actions: {
+    cancel: "Cancel",
+    intro: "Intro",
+    confirm_quit_title: "Confirm",
+    confirm_quit_msg: "Are your sure exit?"
+  }
+};
+export {
+  defaultCommonActionsDictionary as d,
+  getCommonActionsDictionary as g
+};

package/components/CommonActions/index.js

@@ -0,0 +1 @@
+

package/components/CommonActions/tests/constants.js

@@ -0,0 +1,4 @@
+const COMMONACTIONS_PREFIX = "M4LCommonActions";
+export {
+  COMMONACTIONS_PREFIX as C
+};

package/components/CommonActions/tests/index.test.d.ts

@@ -0,0 +1,7 @@
+import { Toaster } from '@m4l/core';
+export type OptionsTest = {
+    id: number;
+    name: string;
+    url: string;
+};
+export declare const mock_toaster: Toaster;

package/components/CommonActions/tests/utils.js

@@ -0,0 +1,7 @@
+import { C as COMMONACTIONS_PREFIX } from "./constants.js";
+const getNameCommonActionsDataTestId = (KEY) => {
+  return `${COMMONACTIONS_PREFIX}-${KEY}`;
+};
+export {
+  getNameCommonActionsDataTestId as g
+};

package/components/DataGrid/assets/icons/datagrid.svg

@@ -1,4 +1,4 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M10 13H6C3.245 13 1 10.755 1 8C1 5.245 3.245 3 6 3H10C12.755 3 15 5.245 15 8C15 10.755 12.755 13 10 13ZM6 4C3.795 4 2 5.795 2 8C2 10.205 3.795 12 6 12H10C12.205 12 14 10.205 14 8C14 5.795 12.205 4 10 4H6Z" fill="#2F3737"/>
-<path d="M10 11C8.345 11 7 9.655 7 8C7 6.345 8.345 5 10 5C11.655 5 13 6.345 13 8C13 9.655 11.655 11 10 11ZM10 6C8.895 6 8 6.895 8 8C8 9.105 8.895 10 10 10C11.105 10 12 9.105 12 8C12 6.895 11.105 6 10 6Z" fill="#2F3737"/>
-</svg>
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10 13H6C3.245 13 1 10.755 1 8C1 5.245 3.245 3 6 3H10C12.755 3 15 5.245 15 8C15 10.755 12.755 13 10 13ZM6 4C3.795 4 2 5.795 2 8C2 10.205 3.795 12 6 12H10C12.205 12 14 10.205 14 8C14 5.795 12.205 4 10 4H6Z" fill="#2F3737"/>
+<path d="M10 11C8.345 11 7 9.655 7 8C7 6.345 8.345 5 10 5C11.655 5 13 6.345 13 8C13 9.655 11.655 11 10 11ZM10 6C8.895 6 8 6.895 8 8C8 9.105 8.895 10 10 10C11.105 10 12 9.105 12 8C12 6.895 11.105 6 10 6Z" fill="#2F3737"/>
+</svg>

package/components/DataGrid/classes/constants.js

@@ -0,0 +1,4 @@
+const componentName = "M4LDataGrid";
+export {
+  componentName as c
+};

package/components/DataGrid/classes/index.d.ts

@@ -2,6 +2,9 @@ import { DataGridClassesType } from './types';
 import { OwnerState } from '../types';
 export declare const dataGridClasses: DataGridClassesType;
 export declare function getDataGridUtilityClass(slot: string): string;
+/**
+ * TODO: Documentar
+ */
 export declare const dataGridUtilityClasses: (ownerState: OwnerState) => {
     root: string;
     actions: string;

package/components/DataGrid/classes/index.js

@@ -0,0 +1,71 @@
+import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
+import { unstable_composeClasses } from "@mui/base";
+import { c as componentName } from "./constants.js";
+const dataGridClasses = generateUtilityClasses(componentName, [
+  /* elements */
+  "root",
+  "actions",
+  "withPager",
+  "withNoPager",
+  "rowsCount",
+  "rowsCountLabel",
+  "rowsCountValue",
+  "densitySkeleton",
+  "actionDensityPopover",
+  "actionFilter",
+  "actionSettings",
+  "tableContaniner",
+  "wrapperDataGridCss",
+  "columnsConfigContainer",
+  "columnsLabelSetColumns",
+  "columnsConfigContent",
+  "columnsConfigGrid",
+  "columnsConfigActions",
+  "formatterColumn",
+  "skeletonFormatter",
+  "actionsFormatter",
+  "actionsConfigContainer",
+  "booleanFormatter",
+  "iconFormatter",
+  /* states or variants of elements */
+  "withActions"
+]);
+function getDataGridUtilityClass(slot) {
+  return generateUtilityClass(componentName, slot);
+}
+const dataGridUtilityClasses = (ownerState) => {
+  const slots = {
+    root: ["root"],
+    actions: ["actions", ownerState.actionsProps.withPager ? "withPager" : "withNoPager"],
+    rowsCount: ["rowsCount"],
+    rowsCountLabel: ["rowsCountLabel"],
+    rowsCountValue: ["rowsCountValue"],
+    densitySkeleton: ["densitySkeleton"],
+    densityRoot: ["densityRoot"],
+    densityPopover: ["densityPopover"],
+    actionFilter: ["actionFilter"],
+    actionSettings: ["actionSettingsRoot"],
+    actionDensityPopover: ["actionDensityPopover"],
+    tableContaniner: ["tableContaniner", ownerState.withActions && "withActions"],
+    wrapperDataGridCss: ["wrapperDataGridCss"],
+    columnsConfigContainer: ["columnsConfigContainer"],
+    columnsLabelSetColumns: ["columnsLabelSetColumns"],
+    columnsConfigContent: ["columnsConfigContent"],
+    columnsConfigGrid: ["columnsConfigGrid"],
+    columnsConfigActions: ["columnsConfigActions"],
+    formatterColumn: ["formatterColumn"],
+    skeletonFormatter: ["skeletonFormatter"],
+    actionsFormatter: ["actionsFormatter"],
+    actionsConfigContainer: ["actionsConfigContainer"],
+    booleanFormatter: ["booleanFormatter"],
+    iconFormatter: ["iconFormatter"]
+  };
+  const composedClasses = unstable_composeClasses(slots, getDataGridUtilityClass, {});
+  return {
+    ...composedClasses
+  };
+};
+export {
+  dataGridUtilityClasses as a,
+  dataGridClasses as d
+};

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

@@ -26,5 +26,5 @@ export interface DataGridClassesType {
     iconFormatter: string;
     withActions: string;
 }
-export declare type BadgeClassesKey = keyof DataGridClassesType;
-export declare type Classes = ReturnType<typeof dataGridUtilityClasses>;
+export type BadgeClassesKey = keyof DataGridClassesType;
+export type Classes = ReturnType<typeof dataGridUtilityClasses>;

package/components/DataGrid/constants.js

@@ -0,0 +1,8 @@
+const DATAGRID_PREFIX_NAME = "M4LDataGrid";
+const DATAGRID_SELECT_COLUMN_KEY = "M4LDataGrid-CheckedColumn";
+const DATAGRID_ACTIONS_COLUMN_KEY = "M4LDataGrid-ActionsColumn";
+export {
+  DATAGRID_PREFIX_NAME as D,
+  DATAGRID_SELECT_COLUMN_KEY as a,
+  DATAGRID_ACTIONS_COLUMN_KEY as b
+};

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

@@ -1,6 +1,8 @@
-/// <reference types="react" />
 import { RowKey } from '../../types';
 import { DataGridContextProps, DataGridProviderProps } from './types';
-declare const DataGridContext: import("react").Context<DataGridContextProps<any, any, any> | null>;
+declare const DataGridContext: import('react').Context<DataGridContextProps<any, any, any> | null>;
+/**
+ * TODO: Documentar
+ */
 declare function DataGridProvider<TRow, TSummaryRow, TKey extends RowKey = RowKey>(props: DataGridProviderProps<TRow, TSummaryRow, TKey>): import("react/jsx-runtime").JSX.Element;
 export { DataGridProvider, DataGridContext };

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

@@ -0,0 +1,230 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useMemo, useEffect, useCallback } from "react";
+const DataGridContext = createContext(null);
+const getColumnConfigByKey = (key, storeColumnsConfig) => {
+  let indexFind = -1;
+  return [
+    storeColumnsConfig.find((column, index) => {
+      if (column.key === key) {
+        indexFind = index;
+      }
+      return column.key === key;
+    }),
+    indexFind
+  ];
+};
+function getColumnsConfig(id, columns, remoteConfig = void 0) {
+  let columnsConfig;
+  if (remoteConfig) {
+    columnsConfig = remoteConfig.columnsConfig;
+  } else {
+    try {
+      const item = window.localStorage.getItem(`${id}_columns_config`);
+      columnsConfig = item !== null ? JSON.parse(item) : [];
+    } catch (_e) {
+      columnsConfig = [];
+    }
+  }
+  return columns.map((column, index) => {
+    const [columnConfig = { ...column }, columnConfigIndex] = getColumnConfigByKey(
+      column.key,
+      columnsConfig
+    );
+    return {
+      key: column.key,
+      name: column.name,
+      hidden: column.hidden === void 0 ? false : column.hidden,
+      index: columnConfigIndex > -1 ? columnConfigIndex : index,
+      visible: columnConfig.visible === void 0 ? true : columnConfig.visible,
+      frozen: columnConfig.frozen === void 0 ? false : columnConfig.frozen,
+      orginalIndex: index,
+      originalVisible: column.visible === void 0 ? true : column.visible,
+      originalFrozen: column.frozen === void 0 ? false : column.frozen
+    };
+  }).sort((a, b) => a.index - b.index);
+}
+function getColumnsWidth(id, columns, remoteConfig) {
+  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 (remoteConfig) {
+      try {
+        width = remoteConfig.columnsWidths.get(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) {
+  localStorage.setItem(`${id}_columns_width`, JSON.stringify([...storeColumnsWidth]));
+}
+function saveColumnsConfig(id, columnsConfig) {
+  localStorage.setItem(`${id}_columns_config`, JSON.stringify(columnsConfig));
+}
+function getIndexRowHeightVariant(variant) {
+  if (variant === "compact") {
+    return 0;
+  }
+  if (variant === "standard") {
+    return 1;
+  }
+  return 2;
+}
+function DataGridProvider(props) {
+  const {
+    id,
+    children,
+    columns,
+    remoteConfig,
+    rows,
+    rowsCount,
+    rowActionsGetter,
+    rowHeights = [28, 32, 36],
+    rowHeaderHeights = [28, 32, 36],
+    initialRowHeightVariant = "compact",
+    checkedRows,
+    onCheckedRowsChange,
+    rowKeyGetter,
+    classes
+  } = props;
+  const [columnsWidths, setColumnsWidths] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [columnsConfig, setColumnsConfigOptions] = useState(
+    () => (
+      //
+      []
+    )
+  );
+  const [rowsFilterCount, setRowFilterCount] = useState(rowsCount);
+  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 finalRowHeights = useMemo(() => rowHeights, [rowHeights]);
+  let timerSaveColumns;
+  useEffect(() => {
+  }, [columnsConfig]);
+  useEffect(() => {
+    setColumnsWidths(getColumnsWidth(id, columns, remoteConfig));
+    setColumnsConfigOptions(getColumnsConfig(id, columns, remoteConfig));
+  }, [columns, id, remoteConfig]);
+  const onChangeColumnsConfig = useCallback(
+    (newColumnsConfig) => {
+      saveColumnsConfig(id, newColumnsConfig);
+      setColumnsConfigOptions(newColumnsConfig);
+    },
+    [setColumnsConfigOptions, id]
+  );
+  const onChangeColumnsOrder = useCallback(
+    (sourceKey, targetKey) => {
+      if (sourceKey === targetKey) {
+        return;
+      }
+      const sourceColumnIndex = columnsConfig.findIndex((c) => c.key === sourceKey);
+      const targetColumnIndex = columnsConfig.findIndex((c) => c.key === targetKey);
+      const reorderedColumnsConfig = [...columnsConfig];
+      reorderedColumnsConfig.splice(
+        targetColumnIndex,
+        0,
+        reorderedColumnsConfig.splice(sourceColumnIndex, 1)[0]
+      );
+      onChangeColumnsConfig(reorderedColumnsConfig);
+    },
+    [columnsConfig, onChangeColumnsConfig]
+  );
+  const onChangeColumnWidth = (columnKey, width) => {
+    columnsWidths.set(columnKey, Math.round(width));
+    if (timerSaveColumns) {
+      clearTimeout(timerSaveColumns);
+    }
+    timerSaveColumns = setTimeout(() => {
+      saveColumnsWidth(id, columnsWidths);
+    }, 500);
+  };
+  useEffect(() => {
+    setColumnsConfigOptions(getColumnsConfig(id, columns));
+  }, [columns]);
+  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,
+    {
+      value: {
+        columnsConfig,
+        columnsWidths,
+        rowsCount: rowsFilterCount,
+        currentRowHeightVariant: currentRowHeightVariant.rowHVariant,
+        currentRowHeight: currentRowHeightVariant.rowHeight,
+        currentRowHeaderHeight: currentRowHeightVariant.rowHeaderHeight,
+        rows,
+        rowHeights: finalRowHeights,
+        checkedRows,
+        onChangeColumnsConfig,
+        onChangeColumnsOrder,
+        onChangeColumnWidth,
+        setRowsCount: setRowFilterCountInternal,
+        rowActionsGetter,
+        classes,
+        setRowHeightVariant: setCurrentRowHeightInternal,
+        onCheckedRowsChange,
+        rowKeyGetter
+      },
+      children
+    }
+  );
+}
+export {
+  DataGridContext as D,
+  DataGridProvider as a
+};

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

@@ -24,7 +24,7 @@ export interface DataGridProviderProps<TRow, TSummaryRow, TKey extends RowKey =
     rowsCount: number;
     classes: Classes;
 }
-export declare type RowHeightState = {
+export type RowHeightState = {
     rowHVariant: RowHeightVariants;
     rowHeight: number;
     rowHeaderHeight: number;

package/components/DataGrid/contexts/FilterContext/index.d.ts

@@ -1,9 +1,12 @@
 import { ReactNode } from 'react';
 import { FilterContextProps } from './types';
-declare const FilterContext: import("react").Context<FilterContextProps>;
-declare type FilterProviderProps = {
+declare const FilterContext: import('react').Context<FilterContextProps>;
+type FilterProviderProps = {
     children: ReactNode;
     initialActiveFilters: boolean;
 };
+/**
+ * TODO: Documentar
+ */
 declare function FilterProvider({ children, initialActiveFilters }: FilterProviderProps): import("react/jsx-runtime").JSX.Element;
 export { FilterProvider, FilterContext };