material-react-table 0.4.5 → 0.4.8

package/dist/menus/MRT_ColumnActionMenu.d.ts

@@ -1,8 +1,8 @@
 import { FC } from 'react';
-import { HeaderGroup } from 'react-table';
+import { MRT_HeaderGroup } from '..';
 interface Props {
     anchorEl: HTMLElement | null;
-    column: HeaderGroup;
+    column: MRT_HeaderGroup;
     setAnchorEl: (anchorEl: HTMLElement | null) => void;
 }
 export declare const MRT_ColumnActionMenu: FC<Props>;

package/dist/menus/MRT_RowActionMenu.d.ts

@@ -1,8 +1,8 @@
 import { FC } from 'react';
-import { Row } from 'react-table';
+import { MRT_Row } from '..';
 interface Props {
     anchorEl: HTMLElement | null;
-    row: Row;
+    row: MRT_Row;
     setAnchorEl: (anchorEl: HTMLElement | null) => void;
     handleEdit: () => void;
 }

package/dist/menus/MRT_ShowHideColumnsMenu.d.ts

@@ -1,7 +1,7 @@
 import { FC } from 'react';
-import { ColumnInstance } from 'react-table';
+import { MRT_ColumnInstance } from '..';
 interface Props {
-    column: ColumnInstance;
+    column: MRT_ColumnInstance;
 }
 export declare const MRT_ShowHideColumnsMenu: FC<Props>;
 export {};

package/dist/useMRT.d.ts

@@ -1,20 +1,24 @@
 import React, { PropsWithChildren } from 'react';
-import { Row, TableInstance } from 'react-table';
+import { MRT_Row, MRT_TableInstance } from '.';
+import { MRT_Icons } from './icons';
+import { MRT_Localization } from './localization';
 import { MaterialReactTableProps } from './MaterialReactTable';
-export interface UseMRT<D extends {} = {}> extends MaterialReactTableProps<D> {
+export declare type UseMRT<D extends {} = {}> = MaterialReactTableProps<D> & {
     anyRowsCanExpand: boolean;
     anyRowsExpanded: boolean;
-    currentEditingRow: Row<D> | null;
+    currentEditingRow: MRT_Row<D> | null;
     densePadding: boolean;
     fullScreen: boolean;
-    setCurrentEditingRow: (currentRowEditingId: Row<D> | null) => void;
+    icons: MRT_Icons;
+    localization: MRT_Localization;
+    setCurrentEditingRow: (currentRowEditingId: MRT_Row<D> | null) => void;
     setDensePadding: (densePadding: boolean) => void;
     setFullScreen: (fullScreen: boolean) => void;
     setShowFilters: (showFilters: boolean) => void;
     setShowSearch: (showSearch: boolean) => void;
     showFilters: boolean;
     showSearch: boolean;
-    tableInstance: TableInstance<D>;
-}
+    tableInstance: MRT_TableInstance<D>;
+};
 export declare const MaterialReactTableProvider: <D extends {}>(props: React.PropsWithChildren<MaterialReactTableProps<D>>) => JSX.Element;
 export declare const useMRT: <D extends {}>() => UseMRT<D>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.4.5",
+  "version": "0.4.8",
   "license": "MIT",
   "name": "material-react-table",
   "description": "A fully featured Material-UI implementation of react-table, inspired by material-table and the mui DataGrid, written from the ground up in TypeScript.",

package/src/@types/react-table-config.d.ts

@@ -1,102 +1,23 @@
-import { ChangeEvent, ReactNode } from 'react';
-import { TableCellProps, TextFieldProps } from '@mui/material';
 import {
-  UseColumnOrderInstanceProps,
-  UseColumnOrderState,
-  UseExpandedHooks,
-  UseExpandedInstanceProps,
-  UseExpandedOptions,
-  UseExpandedRowProps,
-  UseExpandedState,
-  UseFiltersColumnOptions,
-  UseFiltersColumnProps,
-  UseFiltersInstanceProps,
-  UseFiltersOptions,
-  UseFiltersState,
-  UseGlobalFiltersColumnOptions,
-  UseGlobalFiltersInstanceProps,
-  UseGlobalFiltersOptions,
-  UseGlobalFiltersState,
-  UseGroupByCellProps,
-  UseGroupByColumnOptions,
-  UseGroupByColumnProps,
   UseGroupByHooks,
-  UseGroupByInstanceProps,
-  UseGroupByOptions,
-  UseGroupByRowProps,
-  UseGroupByState,
-  UsePaginationInstanceProps,
-  UsePaginationOptions,
-  UsePaginationState,
-  UseResizeColumnsColumnOptions,
-  UseResizeColumnsColumnProps,
-  UseResizeColumnsOptions,
-  UseResizeColumnsState,
   UseRowSelectHooks,
-  UseRowSelectInstanceProps,
-  UseRowSelectOptions,
-  UseRowSelectRowProps,
-  UseRowSelectState,
-  UseRowStateCellProps,
-  UseRowStateInstanceProps,
-  UseRowStateOptions,
-  UseRowStateRowProps,
-  UseRowStateState,
-  UseSortByColumnOptions,
-  UseSortByColumnProps,
   UseSortByHooks,
-  UseSortByInstanceProps,
-  UseSortByOptions,
-  UseSortByState,
 } from 'react-table';
-
-export type MRT_ColumnInterface<D extends {} = {}> =
-  UseFiltersColumnOptions<D> &
-    UseGlobalFiltersColumnOptions<D> &
-    UseGroupByColumnOptions<D> &
-    UseResizeColumnsColumnOptions<D> &
-    UseSortByColumnOptions<D> & {
-      disableFilters?: boolean;
-      Filter?: ({ column }: { column: HeaderGroup<D> }) => ReactNode;
-      editable?: boolean;
-      Edit?: ({ cell, onChange }: { cell: Cell<D> }) => ReactNode;
-      muiTableBodyCellProps?:
-        | TableCellProps
-        | ((cell: Cell<D>) => TableCellProps);
-      muiTableHeadCellProps?:
-        | TableCellProps
-        | ((column: Column<D>) => TableCellProps);
-      muiTableFooterCellProps?:
-        | TableCellProps
-        | ((column: Column<D>) => TableCellProps);
-      muiTableBodyCellEditTextFieldProps?:
-        | TextFieldProps
-        | ((cell: Cell<D>) => TextFieldProps);
-      muiTableHeadCellFilterTextFieldProps?:
-        | TextFieldProps
-        | ((column: Column<D>) => TextFieldProps);
-      onCellEditChange?: (
-        event: ChangeEvent<HTMLInputElement>,
-        cell: Cell<D>,
-      ) => void;
-      onFilterChange?: (
-        event: ChangeEvent<HTMLInputElement>,
-        filterValue: any,
-      ) => void;
-    };
+import {
+  MRT_Cell,
+  MRT_ColumnInstance,
+  MRT_ColumnInterface,
+  MRT_Row,
+  MRT_TableInstance,
+  MRT_TableOptions,
+  MRT_TableState,
+} from '..';
 
 declare module 'react-table' {
+  // take this file as-is, or comment out the sections that don't apply to your plugin configuration
+
   export interface TableOptions<D extends Record<string, unknown>>
-    extends UseExpandedOptions<D>,
-      UseFiltersOptions<D>,
-      UseGlobalFiltersOptions<D>,
-      UseGroupByOptions<D>,
-      UsePaginationOptions<D>,
-      UseResizeColumnsOptions<D>,
-      UseRowSelectOptions<D>,
-      UseRowStateOptions<D>,
-      UseSortByOptions<D>,
-      Record<string, any> {}
+    extends MRT_TableOptions<D> {}
 
   export interface Hooks<
     D extends Record<string, unknown> = Record<string, unknown>,
@@ -107,50 +28,26 @@ declare module 'react-table' {
 
   export interface TableInstance<
     D extends Record<string, unknown> = Record<string, unknown>,
-  > extends UseColumnOrderInstanceProps<D>,
-      UseExpandedInstanceProps<D>,
-      UseFiltersInstanceProps<D>,
-      UseGlobalFiltersInstanceProps<D>,
-      UseGroupByInstanceProps<D>,
-      UsePaginationInstanceProps<D>,
-      UseRowSelectInstanceProps<D>,
-      UseRowStateInstanceProps<D>,
-      UseSortByInstanceProps<D> {}
+  > extends MRT_TableInstance<D> {}
 
   export interface TableState<
     D extends Record<string, unknown> = Record<string, unknown>,
-  > extends UseColumnOrderState<D>,
-      UseExpandedState<D>,
-      UseFiltersState<D>,
-      UseGlobalFiltersState<D>,
-      UseGroupByState<D>,
-      UsePaginationState<D>,
-      UseResizeColumnsState<D>,
-      UseRowSelectState<D>,
-      UseRowStateState<D>,
-      UseSortByState<D> {}
+  > extends MRT_TableState<D> {}
 
   export interface ColumnInterface<
     D extends Record<string, unknown> = Record<string, unknown>,
-  > extends MRT_ColumnInterface {}
+  > extends MRT_ColumnInterface<D> {}
 
   export interface ColumnInstance<
     D extends Record<string, unknown> = Record<string, unknown>,
-  > extends UseFiltersColumnProps<D>,
-      UseGroupByColumnProps<D>,
-      UseResizeColumnsColumnProps<D>,
-      UseSortByColumnProps<D> {}
+  > extends MRT_ColumnInstance<D> {}
 
   export interface Cell<
     D extends Record<string, unknown> = Record<string, unknown>,
     V = any,
-  > extends UseGroupByCellProps<D>,
-      UseRowStateCellProps<D> {}
+  > extends MRT_Cell<D> {}
 
   export interface Row<
     D extends Record<string, unknown> = Record<string, unknown>,
-  > extends UseExpandedRowProps<D>,
-      UseGroupByRowProps<D>,
-      UseRowSelectRowProps<D>,
-      UseRowStateRowProps<D> {}
+  > extends MRT_Row<D> {}
 }

package/src/MaterialReactTable.tsx

@@ -16,27 +16,185 @@ import {
 import {
   Cell,
   Column,
+  ColumnInstance,
+  // ColumnInterface,
   HeaderGroup,
   Row,
   TableInstance,
   TableOptions,
+  TableState,
+  UseColumnOrderInstanceProps,
+  UseColumnOrderState,
+  UseExpandedInstanceProps,
   UseExpandedOptions,
+  UseExpandedRowProps,
+  UseExpandedState,
+  UseFiltersColumnOptions,
+  UseFiltersColumnProps,
+  UseFiltersInstanceProps,
   UseFiltersOptions,
+  UseFiltersState,
+  UseGlobalFiltersColumnOptions,
+  UseGlobalFiltersInstanceProps,
   UseGlobalFiltersOptions,
+  UseGlobalFiltersState,
+  UseGroupByCellProps,
+  UseGroupByColumnOptions,
+  UseGroupByColumnProps,
+  UseGroupByInstanceProps,
   UseGroupByOptions,
+  UseGroupByRowProps,
+  UseGroupByState,
+  UsePaginationInstanceProps,
   UsePaginationOptions,
+  UsePaginationState,
+  UseResizeColumnsColumnOptions,
+  UseResizeColumnsColumnProps,
   UseResizeColumnsOptions,
+  UseResizeColumnsState,
+  UseRowSelectInstanceProps,
   UseRowSelectOptions,
+  UseRowSelectRowProps,
+  UseRowSelectState,
+  UseRowStateCellProps,
+  UseRowStateInstanceProps,
   UseRowStateOptions,
+  UseRowStateRowProps,
+  UseRowStateState,
+  UseSortByColumnOptions,
+  UseSortByColumnProps,
+  UseSortByInstanceProps,
   UseSortByOptions,
+  UseSortByState,
+  UseTableHeaderGroupProps,
+  UseTableInstanceProps,
   UseTableOptions,
 } from 'react-table';
 import { MaterialReactTableProvider } from './useMRT';
 import { MRT_TableContainer } from './table/MRT_TableContainer';
-import { defaultLocalization, MRT_Localization } from './utils/localization';
-import { MRT_ColumnInterface } from './@types/react-table-config';
+import { MRT_Localization, MRT_DefaultLocalization_EN } from './localization';
+import { MRT_Default_Icons, MRT_Icons } from './icons';
 
-export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
+export type MRT_TableOptions<D extends {} = {}> = TableOptions<D> &
+  UseExpandedOptions<D> &
+  UseFiltersOptions<D> &
+  UseGlobalFiltersOptions<D> &
+  UseGroupByOptions<D> &
+  UsePaginationOptions<D> &
+  UseResizeColumnsOptions<D> &
+  UseRowSelectOptions<D> &
+  UseRowStateOptions<D> &
+  UseSortByOptions<D> & {};
+
+export type MRT_TableInstance<D extends {} = {}> = TableInstance<D> &
+  UseTableInstanceProps<D> &
+  UseColumnOrderInstanceProps<D> &
+  UseExpandedInstanceProps<D> &
+  UseFiltersInstanceProps<D> &
+  UseGlobalFiltersInstanceProps<D> &
+  UseGroupByInstanceProps<D> &
+  UsePaginationInstanceProps<D> &
+  UseRowSelectInstanceProps<D> &
+  UseRowStateInstanceProps<D> &
+  UseSortByInstanceProps<D> & {
+    columns: (Column<D> & MRT_ColumnInstance<D>)[];
+    headerGroups: MRT_HeaderGroup<D>[];
+    footerGroups: MRT_HeaderGroup<D>[];
+    state: MRT_TableState<D>;
+    rows: MRT_Row<D>[];
+    page: MRT_Row<D>[];
+    resetResizing: () => void;
+    getToggleAllRowsExpandedProps: () => void;
+  };
+
+export type MRT_ColumnInterface<D extends {} = {}> =
+  // ColumnInterface<D> &
+  UseFiltersColumnOptions<D> &
+    UseGlobalFiltersColumnOptions<D> &
+    UseGroupByColumnOptions<D> &
+    UseResizeColumnsColumnOptions<D> &
+    UseSortByColumnOptions<D> & {
+      Edit?: ({
+        cell,
+        onChange,
+      }: {
+        cell: MRT_Cell<D>;
+        onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+      }) => ReactNode;
+      Filter?: ({ column }: { column: MRT_HeaderGroup<D> }) => ReactNode;
+      Footer?: string;
+      Header?: string;
+      disableFilters?: boolean;
+      editable?: boolean;
+      muiTableBodyCellEditTextFieldProps?:
+        | TextFieldProps
+        | ((cell: MRT_Cell<D>) => TextFieldProps);
+      muiTableBodyCellProps?:
+        | TableCellProps
+        | ((cell: MRT_Cell<D>) => TableCellProps);
+      muiTableFooterCellProps?:
+        | TableCellProps
+        | ((column: Column<D>) => TableCellProps);
+      muiTableHeadCellFilterTextFieldProps?:
+        | TextFieldProps
+        | ((column: Column<D>) => TextFieldProps);
+      muiTableHeadCellProps?:
+        | TableCellProps
+        | ((column: Column<D>) => TableCellProps);
+      onCellEditChange?: (
+        event: ChangeEvent<HTMLInputElement>,
+        cell: MRT_Cell<D>,
+      ) => void;
+      onFilterChange?: (
+        event: ChangeEvent<HTMLInputElement>,
+        filterValue: any,
+      ) => void;
+    };
+
+export type MRT_ColumnInstance<D extends {} = {}> = ColumnInstance<D> &
+  UseFiltersColumnProps<D> &
+  UseGroupByColumnProps<D> &
+  UseResizeColumnsColumnProps<D> &
+  UseSortByColumnProps<D> & {
+    columns?: MRT_ColumnInstance<D>[];
+  };
+
+export type MRT_HeaderGroup<D extends {} = {}> = HeaderGroup<D> &
+  MRT_ColumnInstance<D> &
+  UseTableHeaderGroupProps<D> & {
+    headers: MRT_HeaderGroup<D>[];
+  };
+
+export type MRT_Row<D extends {} = {}> = Row<D> &
+  UseExpandedRowProps<D> &
+  UseGroupByRowProps<D> &
+  UseRowSelectRowProps<D> &
+  UseRowStateRowProps<D> & {
+    cells: MRT_Cell<D>[];
+  };
+
+export type MRT_Cell<D extends {} = {}, _V = any> = Cell<D> &
+  UseGroupByCellProps<D> &
+  UseRowStateCellProps<D> & {};
+
+export type MRT_TableState<D extends {} = {}> = TableState<D> &
+  UseColumnOrderState<D> &
+  UseExpandedState<D> &
+  UseFiltersState<D> &
+  UseGlobalFiltersState<D> &
+  UseGroupByState<D> &
+  UsePaginationState<D> &
+  UseResizeColumnsState<D> &
+  UseRowSelectState<D> &
+  UseRowStateState<D> &
+  UseSortByState<D> & {
+    densePadding?: boolean;
+    fullScreen?: boolean;
+    showFilters?: boolean;
+    showSearchTextField?: boolean;
+  };
+
+export type MaterialReactTableProps<D extends {} = {}> = MRT_TableOptions<D> &
   UseTableOptions<D> &
   UseExpandedOptions<D> &
   UseFiltersOptions<D> &
@@ -48,10 +206,7 @@ export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
   UseRowStateOptions<D> &
   UseSortByOptions<D> & {
     columns: (Column<D> & MRT_ColumnInterface)[];
-    defaultDensePadding?: boolean;
-    defaultFullScreen?: boolean;
-    defaultShowFilters?: boolean;
-    defaultShowSearchTextField?: boolean;
+    data: D[];
     disableColumnActions?: boolean;
     disableColumnHiding?: boolean;
     disableDensePaddingToggle?: boolean;
@@ -59,32 +214,34 @@ export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
     disableFullScreenToggle?: boolean;
     disableSelectAll?: boolean;
     disableSubRowTree?: boolean;
-    enableRowNumbers?: boolean;
     enableColumnGrouping?: boolean;
     enableColumnResizing?: boolean;
     enableRowActions?: boolean;
     enableRowEditing?: boolean;
+    enableRowNumbers?: boolean;
     enableSelection?: boolean;
     hideTableFooter?: boolean;
     hideTableHead?: boolean;
-    hideToolbarInternalActions?: boolean;
     hideToolbarBottom?: boolean;
+    hideToolbarInternalActions?: boolean;
     hideToolbarTop?: boolean;
+    icons?: Partial<MRT_Icons>;
+    initialState?: Partial<MRT_TableState>;
     isFetching?: boolean;
     isLoading?: boolean;
     localization?: Partial<MRT_Localization>;
     muiSearchTextFieldProps?: TextFieldProps;
     muiTableBodyCellEditTextFieldProps?:
       | TextFieldProps
-      | ((cell?: Cell<D>) => TextFieldProps);
+      | ((cell?: MRT_Cell<D>) => TextFieldProps);
     muiTableBodyCellProps?:
       | TableCellProps
-      | ((cell?: Cell<D>) => TableCellProps);
+      | ((cell?: MRT_Cell<D>) => TableCellProps);
     muiTableBodyProps?: TableBodyProps;
     muiTableBodyRowProps?: TableRowProps | ((row: Row<D>) => TableRowProps);
     muiTableContainerProps?:
       | TableContainerProps
-      | ((table: TableInstance<D>) => TableContainerProps);
+      | ((table: MRT_TableInstance<D>) => TableContainerProps);
     muiTableDetailPanelProps?:
       | TableCellProps
       | ((row: Row<D>) => TableCellProps);
@@ -94,7 +251,7 @@ export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
     muiTableFooterProps?: TableFooterProps;
     muiTableFooterRowProps?:
       | TableRowProps
-      | ((footerGroup: HeaderGroup<D>) => TableRowProps);
+      | ((footerGroup: MRT_HeaderGroup<D>) => TableRowProps);
     muiTableHeadCellFilterTextFieldProps?:
       | TextFieldProps
       | ((column: Column<D>) => TextFieldProps);
@@ -104,23 +261,25 @@ export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
     muiTableHeadProps?: TableHeadProps;
     muiTableHeadRowProps?:
       | TableRowProps
-      | ((row: HeaderGroup<D>) => TableRowProps);
+      | ((row: MRT_HeaderGroup<D>) => TableRowProps);
     muiTablePaginationProps?:
       | Partial<TablePaginationProps>
-      | ((tableInstance: TableInstance<D>) => Partial<TablePaginationProps>);
+      | ((
+          tableInstance: MRT_TableInstance<D>,
+        ) => Partial<TablePaginationProps>);
     muiTableProps?: TableProps;
     muiTableToolbarAlertBannerProps?:
       | AlertProps
-      | ((tableInstance: TableInstance<D>) => AlertProps);
+      | ((tableInstance: MRT_TableInstance<D>) => AlertProps);
     muiTableToolbarBottomProps?:
       | ToolbarProps
-      | ((tableInstance: TableInstance<D>) => ToolbarProps);
+      | ((tableInstance: MRT_TableInstance<D>) => ToolbarProps);
     muiTableToolbarTopProps?:
       | ToolbarProps
-      | ((tableInstance: TableInstance<D>) => ToolbarProps);
+      | ((tableInstance: MRT_TableInstance<D>) => ToolbarProps);
     onCellClick?: (
       event: MouseEvent<HTMLTableCellElement>,
-      cell: Cell<D>,
+      cell: MRT_Cell<D>,
     ) => void;
     onColumnHide?: (column: Column<D>, visibleColumns: Column<D>[]) => void;
     onDetailPanelClick?: (
@@ -147,16 +306,18 @@ export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
     renderDetailPanel?: (row: Row<D>) => ReactNode;
     renderRowActionMenuItems?: (
       rowData: Row<D>,
-      tableInstance: TableInstance<D>,
+      tableInstance: MRT_TableInstance<D>,
       closeMenu: () => void,
     ) => ReactNode[];
     renderRowActions?: (
       row: Row<D>,
-      tableInstance: TableInstance<D>,
+      tableInstance: MRT_TableInstance<D>,
+    ) => ReactNode;
+    renderToolbarCustomActions?: (
+      tableInstance: MRT_TableInstance<D>,
     ) => ReactNode;
-    renderToolbarCustomActions?: (tableInstance: TableInstance<D>) => ReactNode;
     renderToolbarInternalActions?: (
-      tableInstance: TableInstance<D>,
+      tableInstance: MRT_TableInstance<D>,
       {
         MRT_ToggleSearchButton,
         MRT_ToggleFiltersButton,
@@ -175,7 +336,8 @@ export type MaterialReactTableProps<D extends {} = {}> = TableOptions<D> &
 
 export default <D extends {}>({
   defaultColumn = { minWidth: 50, maxWidth: 1000 },
-  localization = defaultLocalization,
+  icons,
+  localization,
   positionActionsColumn = 'first',
   positionPagination = 'bottom',
   positionToolbarActions = 'top',
@@ -184,7 +346,8 @@ export default <D extends {}>({
 }: MaterialReactTableProps<D>) => (
   <MaterialReactTableProvider
     defaultColumn={defaultColumn}
-    localization={{ ...defaultLocalization, ...localization }}
+    icons={{ ...MRT_Default_Icons, ...icons }}
+    localization={{ ...MRT_DefaultLocalization_EN, ...localization }}
     positionActionsColumn={positionActionsColumn}
     positionPagination={positionPagination}
     positionToolbarActions={positionToolbarActions}

package/src/body/MRT_TableBody.tsx

@@ -2,6 +2,7 @@ import React, { FC } from 'react';
 import { styled, TableBody as MuiTableBody } from '@mui/material';
 import { MRT_TableBodyRow } from './MRT_TableBodyRow';
 import { useMRT } from '../useMRT';
+import { MRT_Row } from '..';
 
 const TableBody = styled(MuiTableBody)({
   overflowY: 'hidden',
@@ -25,7 +26,7 @@ export const MRT_TableBody: FC<Props> = () => {
 
   return (
     <TableBody {...tableBodyProps}>
-      {rows.map((row) => {
+      {rows.map((row: MRT_Row) => {
         tableInstance.prepareRow(row);
         return <MRT_TableBodyRow key={row.getRowProps().key} row={row} />;
       })}

package/src/body/MRT_TableBodyCell.tsx

@@ -1,8 +1,8 @@
 import React, { FC, MouseEvent } from 'react';
 import { styled, TableCell as MuiTableCell } from '@mui/material';
-import { Cell } from 'react-table';
 import { useMRT } from '../useMRT';
 import { MRT_EditCellTextField } from '../inputs/MRT_EditCellTextField';
+import { MRT_Cell } from '..';
 
 export const MRT_StyledTableBodyCell = styled(MuiTableCell, {
   shouldForwardProp: (prop) => prop !== 'densePadding',
@@ -13,7 +13,7 @@ export const MRT_StyledTableBodyCell = styled(MuiTableCell, {
 }));
 
 interface Props {
-  cell: Cell;
+  cell: MRT_Cell;
 }
 
 export const MRT_TableBodyCell: FC<Props> = ({ cell }) => {

package/src/body/MRT_TableBodyRow.tsx

@@ -1,6 +1,5 @@
 import React, { FC, MouseEvent } from 'react';
 import { alpha, styled, TableRow as MuiTableRow } from '@mui/material';
-import { Row } from 'react-table';
 import {
   MRT_StyledTableBodyCell,
   MRT_TableBodyCell,
@@ -10,6 +9,7 @@ import { MRT_TableDetailPanel } from './MRT_TableDetailPanel';
 import { MRT_ExpandButton } from '../buttons/MRT_ExpandButton';
 import { MRT_SelectCheckbox } from '../inputs/MRT_SelectCheckbox';
 import { MRT_ToggleRowActionMenuButton } from '../buttons/MRT_ToggleRowActionMenuButton';
+import { MRT_Cell, MRT_Row } from '..';
 
 export const TableRow = styled(MuiTableRow, {
   shouldForwardProp: (prop) => prop !== 'isSelected',
@@ -20,7 +20,7 @@ export const TableRow = styled(MuiTableRow, {
 }));
 
 interface Props {
-  row: Row;
+  row: MRT_Row;
 }
 
 export const MRT_TableBodyRow: FC<Props> = ({ row }) => {
@@ -63,19 +63,21 @@ export const MRT_TableBodyRow: FC<Props> = ({ row }) => {
         {enableRowNumbers && (
           <MRT_StyledTableBodyCell>{row.index + 1}</MRT_StyledTableBodyCell>
         )}
-        {(enableRowActions || enableRowEditing) && positionActionsColumn === 'first' && (
-          <MRT_ToggleRowActionMenuButton row={row} />
-        )}
+        {(enableRowActions || enableRowEditing) &&
+          positionActionsColumn === 'first' && (
+            <MRT_ToggleRowActionMenuButton row={row} />
+          )}
         {(anyRowsCanExpand || renderDetailPanel) && (
           <MRT_ExpandButton row={row} />
         )}
         {enableSelection && <MRT_SelectCheckbox row={row} />}
-        {row.cells.map((cell) => (
+        {row.cells.map((cell: MRT_Cell) => (
           <MRT_TableBodyCell key={cell.getCellProps().key} cell={cell} />
         ))}
-        {(enableRowActions || enableRowEditing) && positionActionsColumn === 'last' && (
-          <MRT_ToggleRowActionMenuButton row={row} />
-        )}
+        {(enableRowActions || enableRowEditing) &&
+          positionActionsColumn === 'last' && (
+            <MRT_ToggleRowActionMenuButton row={row} />
+          )}
       </TableRow>
       {renderDetailPanel && <MRT_TableDetailPanel row={row} />}
     </>