@m4l/components 7.0.0 → 7.1.2

package/components/DataGrid/subcomponents/Actions/subcomponents/hooks/useModalSettings/index.js

@@ -0,0 +1,63 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useModuleDictionary, useEnvironment } from "@m4l/core";
+import { useIsMobile } from "@m4l/graphics";
+import { useRef, useCallback } from "react";
+import { u as useDataGrid } from "../../../../../hooks/useDataGrid.js";
+import { u as useModal } from "../../../../../../../hooks/useModal/index.js";
+import { D as DataGridRoot } from "../../../../../styles.js";
+import { C as ColumnsConfig } from "../../Settings/subcomponents/ColumnsConfig/index.js";
+import { W as WindowBase } from "../../../../../../modal/WindowBase/index.js";
+import { A as Actions } from "../../../../../../CommonActions/components/Actions/index.js";
+import { A as ActionCancel } from "../../../../../../CommonActions/components/ActionCancel/index.js";
+import { A as ActionIntro } from "../../../../../../CommonActions/components/ActionIntro/index.js";
+const useModalSettings = () => {
+  const { openModal, closeModal } = useModal();
+  const { columnsConfig, onChangeColumnsConfig } = useDataGrid();
+  const { getLabel } = useModuleDictionary();
+  const { host_static_assets, environment_assets } = useEnvironment();
+  const isMobile = useIsMobile();
+  const { classes } = useDataGrid();
+  const ref = useRef(null);
+  const onCloseSettings = useCallback(() => {
+    closeModal();
+  }, [closeModal]);
+  const onClickIntro = useCallback(() => {
+    if (ref.current?.onClickIntro) {
+      ref.current.onClickIntro();
+    }
+  }, []);
+  const onClickSettings = () => {
+    openModal({
+      initialWidth: 500,
+      initialHeigth: 680,
+      fullScreen: isMobile,
+      window: /* @__PURE__ */ jsxs(
+        WindowBase,
+        {
+          title: getLabel("data_grid.settings_title"),
+          urlIcon: `${host_static_assets}/${environment_assets}/frontend/components/data_grid/assets/icons/configuration.svg`,
+          children: [
+            /* @__PURE__ */ jsx(DataGridRoot, { className: classes.root, children: /* @__PURE__ */ jsx("div", { className: classes.tableContaniner, style: { inset: "0" }, children: /* @__PURE__ */ jsx("div", { className: classes.wrapperDataGridCss, children: /* @__PURE__ */ jsx(
+              ColumnsConfig,
+              {
+                ref,
+                columnsConfig,
+                onChangeColumnsConfig,
+                onCloseSettings,
+                classes
+              }
+            ) }) }) }),
+            /* @__PURE__ */ jsxs(Actions, { children: [
+              /* @__PURE__ */ jsx(ActionCancel, { onClick: closeModal }),
+              /* @__PURE__ */ jsx(ActionIntro, { onClick: onClickIntro })
+            ] })
+          ]
+        }
+      )
+    });
+  };
+  return onClickSettings;
+};
+export {
+  useModalSettings as u
+};

package/components/DataGrid/subcomponents/Actions/subcomponents/hooks/useModalSettings/types.d.ts

@@ -1,4 +1,4 @@
-export declare type ColumnsConfigRef = {
+export type ColumnsConfigRef = {
     onClickIntro: () => void;
     current: HTMLDivElement | null;
 };

package/components/DataGrid/subcomponents/Actions/types.d.ts

@@ -1,4 +1,4 @@
-import type { PagerProps } from '../../../mui_extended/Pager/types';
+import { PagerProps } from '../../../mui_extended/Pager/types';
 import { SettingsProps } from './subcomponents/Settings/types';
 export interface ActionsProps {
     withSettings?: boolean;
@@ -8,4 +8,4 @@ export interface ActionsProps {
     pagerOptions?: PagerProps;
     withLocalFilters?: boolean;
 }
-export declare type InternalActionsProps = ActionsProps;
+export type InternalActionsProps = ActionsProps;

package/components/DataGrid/subcomponents/Table/hooks/getDragHeaderRenderer.d.ts

@@ -1,3 +1,6 @@
 import { FunctionComponent } from 'react';
 import { HeaderRendererProps } from 'react-data-grid';
+/**
+ * TODO: Documentar
+ */
 export declare const getDragHeaderRenderer: <TRow, TSummaryRow>(handleColumnsReorder: (sourceKey: string, targetKey: string) => void) => FunctionComponent<HeaderRendererProps<TRow, TSummaryRow>>;

package/components/DataGrid/subcomponents/Table/hooks/getDragHeaderRenderer.js

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { D as DraggableHeaderRenderer } from "../subcomponents/DraggableHeaderRenderer.js";
+const getDragHeaderRenderer = (handleColumnsReorder) => {
+  function HeaderRenderer(props) {
+    return /* @__PURE__ */ jsx(DraggableHeaderRenderer, { ...props, onColumnsReorder: handleColumnsReorder });
+  }
+  return HeaderRenderer;
+};
+export {
+  getDragHeaderRenderer as g
+};

package/components/DataGrid/subcomponents/Table/hooks/useFocusRef.d.ts

@@ -1,5 +1,7 @@
-/// <reference types="react" />
+/**
+ * TODO: Documentar
+ */
 export declare function useFocusRef<T extends HTMLOrSVGElement>(isSelected: boolean): {
-    ref: import("react").RefObject<T>;
+    ref: import('react').RefObject<T>;
     tabIndex: number;
 };

package/components/DataGrid/subcomponents/Table/hooks/useFocusRef.js

@@ -0,0 +1,17 @@
+import { useRef, useLayoutEffect } from "react";
+function useFocusRef(isSelected) {
+  const ref = useRef(null);
+  useLayoutEffect(() => {
+    if (!isSelected) {
+      return;
+    }
+    ref.current?.focus({ preventScroll: true });
+  }, [isSelected]);
+  return {
+    ref,
+    tabIndex: isSelected ? 0 : -1
+  };
+}
+export {
+  useFocusRef as u
+};

package/components/DataGrid/subcomponents/Table/hooks/useSortColumnsRows.d.ts

@@ -1,8 +1,10 @@
-/// <reference types="react" />
 import { Column, SortColumn } from 'react-data-grid';
+/**
+ * TODO: Documentar
+ */
 export declare const useSortColumnsRows: <TRow, TSummaryRow>(sourceColumns: readonly Column<TRow, TSummaryRow>[], sourceRows: readonly TRow[]) => {
     finalColumns: readonly Column<TRow, TSummaryRow>[];
     sortColumns: readonly SortColumn[];
-    setSortColumns: import("react").Dispatch<import("react").SetStateAction<readonly SortColumn[]>>;
+    setSortColumns: import('react').Dispatch<import('react').SetStateAction<readonly SortColumn[]>>;
     finalRows: readonly TRow[];
 };

package/components/DataGrid/subcomponents/Table/hooks/useSortColumnsRows.js

@@ -0,0 +1,191 @@
+import { useState, useEffect, useMemo } from "react";
+import { g as getDragHeaderRenderer } from "./getDragHeaderRenderer.js";
+import { A as ActionsColumn } from "../subcomponents/ActionsColumn.js";
+import { f as filterColumnClassName, S as SelectColumn } from "../subcomponents/SelectColumn.js";
+import { useModuleSkeleton, getPropertyByString } from "@m4l/core";
+import { u as useFilters } from "../../../hooks/useFilters.js";
+import { u as useDataGrid } from "../../../hooks/useDataGrid.js";
+import { S as SkeletonFormatter } from "../subcomponents/SkeletonFormatter/index.js";
+import { a as DATAGRID_SELECT_COLUMN_KEY } from "../../../constants.js";
+function getComparator(columns, sortColumn) {
+  const column = columns.find((d) => d.key === sortColumn);
+  let typeOrder = "string";
+  if (column) {
+    typeOrder = column.type || "string";
+  }
+  switch (typeOrder) {
+    case "number":
+      return (a, b) => {
+        try {
+          return Number(a[sortColumn]) - Number(b[sortColumn]);
+        } catch (_e) {
+          return -1;
+        }
+      };
+    default:
+      return (a, b) => {
+        try {
+          return a[sortColumn].toString().localeCompare(b[sortColumn].toString());
+        } catch (_e) {
+          return -1;
+        }
+      };
+  }
+}
+const getColumIndex = (key, columnsConfig) => columnsConfig.findIndex((columnConfig) => columnConfig.key === key);
+const getInOrderColumns = (columns, hasCheckedRows, columnsConfig, columnsWidths, rowActionsGetter) => {
+  let filteredSortedColumns = columns.filter((column) => {
+    const columnConfigIndex = getColumIndex(column.key, columnsConfig);
+    const visible = columnConfigIndex > -1 ? columnsConfig[columnConfigIndex].visible : true;
+    return !column.hidden && visible;
+  }).sort(
+    (a, b) => (
+      // Sort for index
+      getColumIndex(a.key, columnsConfig) - getColumIndex(b.key, columnsConfig)
+    )
+  ).map((columnSorted) => {
+    const columnConfigIndex = getColumIndex(columnSorted.key, columnsConfig);
+    return {
+      ...columnSorted,
+      frozen: columnConfigIndex > -1 ? columnsConfig[columnConfigIndex].frozen : true,
+      width: typeof columnsWidths.get(columnSorted.key) === "number" ? columnsWidths.get(columnSorted.key) : columnSorted.width
+    };
+  }).sort((a, b) => {
+    const order = (a.frozen === void 0 || a.frozen === false) === (b.frozen === void 0 || b.frozen === false) ? 0 : a.frozen ? -1 : 1;
+    return order;
+  });
+  if (rowActionsGetter) {
+    filteredSortedColumns = [ActionsColumn, ...filteredSortedColumns];
+  }
+  if (hasCheckedRows) {
+    filteredSortedColumns = [SelectColumn, ...filteredSortedColumns];
+  }
+  return filteredSortedColumns;
+};
+const getAligByType = (columnType) => {
+  switch (columnType) {
+    case "string":
+      return "left";
+    case "date":
+    case "boolean":
+    case "custom":
+      return "center";
+    case "number":
+      return "right";
+  }
+  return "left";
+};
+const useSortColumnsRows = (sourceColumns, sourceRows) => {
+  const {
+    columnsConfig,
+    columnsWidths,
+    onChangeColumnsOrder,
+    rowActionsGetter,
+    checkedRows,
+    onCheckedRowsChange
+  } = useDataGrid();
+  const [columns, setColumns] = useState(() => []);
+  const [sortColumns, setSortColumns] = useState([]);
+  const isSkeleton = useModuleSkeleton();
+  const { activeFilters, filters } = useFilters();
+  const findKeyInColumns = (key, cols) => {
+    const index = cols.findIndex((column) => key === column.key && column.hidden === false);
+    return index !== -1;
+  };
+  useEffect(() => {
+    setColumns(
+      getInOrderColumns(
+        sourceColumns,
+        !!checkedRows && !!onCheckedRowsChange,
+        //Si están seteados se habilita el múltipe
+        columnsConfig,
+        columnsWidths,
+        rowActionsGetter
+      )
+    );
+    const finalSortedColumns = sortColumns.filter(
+      (sortColumn) => findKeyInColumns(sortColumn.columnKey, sourceColumns)
+    );
+    if (JSON.stringify(finalSortedColumns) !== JSON.stringify(sortColumns)) {
+      setSortColumns(finalSortedColumns);
+    }
+  }, [sourceColumns, columnsConfig, rowActionsGetter]);
+  const finalColumns = useMemo(() => {
+    const DragAndDropHeaderRenderer = getDragHeaderRenderer(onChangeColumnsOrder);
+    return columns.map((c) => {
+      const newColumn = {
+        ...c,
+        cellClass: c.align !== void 0 ? `rdg-cell-align-${c.align}` : `rdg-cell-align-${getAligByType(c.type)}`
+      };
+      if (newColumn.key === DATAGRID_SELECT_COLUMN_KEY || newColumn.isDraggable !== void 0 && newColumn.isDraggable === false) {
+        return newColumn;
+      }
+      if (isSkeleton) {
+        newColumn.headerRenderer = SkeletonFormatter;
+        newColumn.formatter = SkeletonFormatter;
+      }
+      if (newColumn.headerRenderer) {
+        newColumn.withinHeaderRenderer = newColumn.headerRenderer;
+      }
+      if ((newColumn?.withFilter === void 0 || newColumn.withFilter === true) && activeFilters) {
+        newColumn.headerCellClass = filterColumnClassName;
+      }
+      newColumn.headerRenderer = DragAndDropHeaderRenderer;
+      return newColumn;
+    });
+  }, [isSkeleton, columns, activeFilters, onChangeColumnsOrder]);
+  const finalRows = useMemo(() => {
+    const nextRows = sourceRows.filter((r) => {
+      if (!filters || filters.size === 0) {
+        return true;
+      }
+      const iterator = filters.entries();
+      let valReturn = true;
+      for (let i = 0; i < filters.size; i++) {
+        const entry = iterator.next().value;
+        const columnKey = entry?.[0] ?? "";
+        const columnFilter = entry?.[1] ?? { value: "", customFilter: void 0 };
+        let valCell;
+        const valueMaybeString = getPropertyByString(r, columnKey);
+        let fixedValue;
+        if (typeof valueMaybeString === "string") {
+          fixedValue = valueMaybeString;
+        } else {
+          fixedValue = "";
+        }
+        try {
+          if (columnFilter.customFilter) {
+            valReturn = valReturn && columnFilter.customFilter(r, columnFilter.value);
+          } else {
+            valCell = fixedValue;
+            valReturn = valReturn && valCell.includes(columnFilter.value);
+          }
+        } catch (_e) {
+          continue;
+        }
+        if (!valReturn) {
+          break;
+        }
+      }
+      return valReturn;
+    });
+    if (sortColumns.length === 0) {
+      return nextRows;
+    }
+    nextRows.sort((a, b) => {
+      for (const sort of sortColumns) {
+        const comparator = getComparator(columns, sort.columnKey);
+        const compResult = comparator(a, b);
+        if (compResult !== 0) {
+          return sort.direction === "ASC" ? compResult : -compResult;
+        }
+      }
+      return 0;
+    });
+    return nextRows;
+  }, [sourceRows, sortColumns, filters]);
+  return { finalColumns, sortColumns, setSortColumns, finalRows };
+};
+export {
+  useSortColumnsRows as u
+};

package/components/DataGrid/subcomponents/Table/index.d.ts

@@ -1,2 +1,5 @@
 import { GridProps, RowKey } from '../../types';
+/**
+ * TODO: Documentar
+ */
 export declare function Table<TRow, TSummaryRow, TKey extends RowKey = RowKey>(props: GridProps<TRow, TSummaryRow, TKey>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,77 @@
+import { jsx } from "react/jsx-runtime";
+import { useRef, useEffect } from "react";
+import DataGrid from "react-data-grid";
+import { DndProvider } from "react-dnd";
+import { HTML5Backend } from "react-dnd-html5-backend";
+import { C as CheckboxFormatter } from "./subcomponents/CheckboxFormatter.js";
+import { a as filterHeight } from "./subcomponents/SelectColumn.js";
+import { u as useSortColumnsRows } from "./hooks/useSortColumnsRows.js";
+import { u as useFilters } from "../../hooks/useFilters.js";
+import { u as useDataGrid } from "../../hooks/useDataGrid.js";
+function Table(props) {
+  const { columns, rows, onRowsChange, rowKeyGetter, selectedRows, onSelectedRowsChange } = props;
+  const { finalColumns, sortColumns, setSortColumns, finalRows } = useSortColumnsRows(
+    columns,
+    rows
+  );
+  const { activeFilters } = useFilters();
+  const { onChangeColumnWidth, setRowsCount, currentRowHeight, currentRowHeaderHeight, classes } = useDataGrid();
+  const ref_data_grid = useRef(null);
+  const onRowClick = (row) => {
+    if (selectedRows && onSelectedRowsChange) {
+      if (selectedRows.entries().next().value) {
+        if (selectedRows.entries().next().value?.[1] === rowKeyGetter(row)) {
+          return;
+        }
+      }
+      const mySet = /* @__PURE__ */ new Set([rowKeyGetter(row)]);
+      onSelectedRowsChange(mySet);
+    }
+  };
+  useEffect(() => {
+    let columnIndice = 0;
+    for (const column of finalColumns) {
+      const index = sortColumns.findIndex((sortColumn) => column.key === sortColumn.columnKey);
+      if (index !== -1) {
+        ref_data_grid.current?.element?.querySelector(`[role="columnheader"][aria-colindex="${columnIndice + 1}"]`)?.setAttribute("aria-columnsort", `${sortColumns[index].direction}`);
+      } else {
+        ref_data_grid.current?.element?.querySelector(`[role="columnheader"][aria-colindex="${columnIndice + 1}"]`)?.removeAttribute("aria-columnsort");
+      }
+      columnIndice++;
+    }
+  }, [sortColumns, finalColumns]);
+  useEffect(() => {
+    setRowsCount(finalRows.length);
+  }, [finalRows]);
+  const onColumnResize = (idx, width) => {
+    onChangeColumnWidth(finalColumns[idx].key, width);
+  };
+  const onChangeSort = (newSortColumns) => {
+    setSortColumns(newSortColumns);
+  };
+  return /* @__PURE__ */ jsx("div", { className: classes.tableContaniner, id: "WrapperTable", children: /* @__PURE__ */ jsx("div", { className: classes.wrapperDataGridCss, children: /* @__PURE__ */ jsx(DndProvider, { backend: HTML5Backend, context: window, children: /* @__PURE__ */ jsx(
+    DataGrid,
+    {
+      className: "fill-grid rdg-light",
+      ref: ref_data_grid,
+      headerRowHeight: activeFilters ? currentRowHeaderHeight + filterHeight : currentRowHeaderHeight,
+      columns: finalColumns,
+      sortColumns,
+      onSortColumnsChange: onChangeSort,
+      onColumnResize,
+      rows: finalRows,
+      onRowsChange,
+      selectedRows,
+      onSelectedRowsChange,
+      onRowClick,
+      rowHeight: currentRowHeight,
+      rowKeyGetter,
+      cellNavigationMode: "LOOP_OVER_ROW",
+      components: { checkboxFormatter: CheckboxFormatter },
+      defaultColumnOptions: { resizable: true, sortable: true }
+    }
+  ) }) }) });
+}
+export {
+  Table as T
+};

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

@@ -0,0 +1,46 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { u as useDataGrid } from "../../../hooks/useDataGrid.js";
+import { useTheme } from "@mui/material";
+import { b as DATAGRID_ACTIONS_COLUMN_KEY } from "../../../constants.js";
+import { M as MenuActions } from "../../../../mui_extended/MenuActions/MenuActions.js";
+function ActionsFormatter(props) {
+  const { rowActionsGetter, classes } = useDataGrid();
+  const theme = useTheme();
+  if (rowActionsGetter === void 0) {
+    return /* @__PURE__ */ jsx(Fragment, {});
+  }
+  return /* @__PURE__ */ jsx(
+    MenuActions,
+    {
+      arrowType: "top-left",
+      objItem: props.row,
+      menuActions: rowActionsGetter,
+      className: classes.actionsFormatter,
+      menuActionSx: theme.components?.M4LDataGridActionsFormatter?.styleOverrides,
+      marginTop: 1,
+      marginLeft: "-11px",
+      anchorOrigin: { vertical: "bottom", horizontal: "left" },
+      transformOrigin: { vertical: "top", horizontal: "left" }
+    }
+  );
+}
+const ActionsColumn = {
+  key: DATAGRID_ACTIONS_COLUMN_KEY,
+  // name: getLabel(dictionary.LABEL_ACTIONS),
+  name: getActionLabel(),
+  width: 32,
+  minWidth: 32,
+  isDraggable: false,
+  withFilter: false,
+  resizable: true,
+  sortable: false,
+  frozen: true,
+  type: "custom",
+  formatter: ActionsFormatter
+};
+function getActionLabel() {
+  return "";
+}
+export {
+  ActionsColumn as A
+};

package/components/DataGrid/subcomponents/Table/subcomponents/CheckboxFormatter.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import { CheckboxFormatterProps } from 'react-data-grid';
-export declare const CheckboxFormatter: import("react").ForwardRefExoticComponent<CheckboxFormatterProps & import("react").RefAttributes<HTMLInputElement>>;
+export declare const CheckboxFormatter: import('react').ForwardRefExoticComponent<CheckboxFormatterProps & import('react').RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,26 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { C as CheckboxIcon, a as CheckboxCheckedIcon, b as CheckboxIndeterminateIcon } from "./CustomIcons.js";
+import { Checkbox } from "@mui/material";
+const CheckboxFormatter = forwardRef(
+  function CheckboxFormatter2({ onChange, checked, ...props }, _ref) {
+    function handleChange(e) {
+      onChange(e.target.checked, e.nativeEvent.shiftKey);
+    }
+    return /* @__PURE__ */ jsx(
+      Checkbox,
+      {
+        checked,
+        size: "small",
+        icon: /* @__PURE__ */ jsx(CheckboxIcon, {}),
+        checkedIcon: /* @__PURE__ */ jsx(CheckboxCheckedIcon, {}),
+        indeterminateIcon: /* @__PURE__ */ jsx(CheckboxIndeterminateIcon, {}),
+        onChange: handleChange,
+        ...props
+      }
+    );
+  }
+);
+export {
+  CheckboxFormatter as C
+};

package/components/DataGrid/subcomponents/Table/subcomponents/CustomIcons.d.ts

@@ -1,14 +1,53 @@
 import { SvgIconProps } from '@mui/material';
+/**
+ * TODO: Documentar
+ */
 export declare function CloseIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function StarIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function InfoIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function WarningIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function SuccessIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function ErrorIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function CheckboxIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function CheckboxCheckedIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function CheckboxIndeterminateIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function InputSelectIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function TreeViewCollapseIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function TreeViewExpandIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: Documentar
+ */
 export declare function TreeViewEndIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+import { jsx } from "react/jsx-runtime";
+import { SvgIcon } from "@mui/material";
+function CheckboxIcon(props) {
+  return /* @__PURE__ */ jsx(SvgIcon, { ...props, children: /* @__PURE__ */ jsx("path", { d: "M17 3a4 4 0 014 4v10a4 4 0 01-4 4H7a4 4 0 01-4-4V7a4 4 0 014-4h10zm0 2H7a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2z" }) });
+}
+function CheckboxCheckedIcon(props) {
+  return /* @__PURE__ */ jsx(SvgIcon, { ...props, children: /* @__PURE__ */ jsx("path", { d: "M17 3a4 4 0 014 4v10a4 4 0 01-4 4H7a4 4 0 01-4-4V7a4 4 0 014-4h10zm-1.372 4.972a1.006 1.006 0 00-.928.388l-3.78 5-1.63-2.08a1.001 1.001 0 00-1.58 1.23l2.44 3.11a1 1 0 001.58-.01l4.57-6v-.03a1.006 1.006 0 00-.672-1.608z" }) });
+}
+function CheckboxIndeterminateIcon(props) {
+  return /* @__PURE__ */ jsx(SvgIcon, { ...props, children: /* @__PURE__ */ jsx("path", { d: "M17 3a4 4 0 014 4v10a4 4 0 01-4 4H7a4 4 0 01-4-4V7a4 4 0 014-4h10zm-1.75 8h-6.5a.75.75 0 00-.75.75v.5c0 .414.336.75.75.75h6.5a.75.75 0 00.75-.75v-.5a.75.75 0 00-.75-.75z" }) });
+}
+export {
+  CheckboxIcon as C,
+  CheckboxCheckedIcon as a,
+  CheckboxIndeterminateIcon as b
+};

package/components/DataGrid/subcomponents/Table/subcomponents/DraggableHeaderRenderer.d.ts

@@ -2,5 +2,8 @@ import { HeaderRendererProps } from 'react-data-grid';
 interface DraggableHeaderRendererProps<TRow> extends HeaderRendererProps<TRow> {
     onColumnsReorder: (sourceKey: string, targetKey: string) => void;
 }
+/**
+ * TODO: Documentar
+ */
 export declare function DraggableHeaderRenderer<TRow>(props: DraggableHeaderRendererProps<TRow>): any;
 export {};