Material React Table

1import React, { FC, useMemo } from 'react';
2import MaterialReactTable, { MRT_ColumnDef } from 'material-react-table';
3
4const Example: FC = () => {
5  const columns = useMemo(
6    () =>
7      [
8        {
9          accessorKey: 'id',
10          enableColumnFilter: false, // could disable just this column's filter
11          header: 'ID',
12        },
13        //column definitions...
14        {
15          accessorKey: 'firstName',
16          header: 'First Name',
17        },
18        {
19          accessorKey: 'middleName',
20          header: 'Middle Name',
21        },
22        {
23          accessorKey: 'lastName',
24          header: 'Last Name',
25        },
26        
27      ] as MRT_ColumnDef<typeof data[0]>[],
28    [],
29  );
30
31  const data = useMemo(
32    //data definitions...
33    () => [
34      {
35        id: 1,
36        firstName: 'Hugh',
37        middleName: 'Jay',
38        lastName: 'Mungus',
39      },
40      {
41        id: 2,
42        firstName: 'Leroy',
43        middleName: 'Leroy',
44        lastName: 'Jenkins',
45      },
46    ],
47    [],
48    
49  );
50
51  return (
52    <MaterialReactTable
53      columns={columns}
54      data={data}
55      enableColumnFilters={false} //disable all column filters
56    />
57  );
58};
59
60export default Example;
61

1import React, { FC, useMemo } from 'react';
2import MaterialReactTable, { MRT_ColumnDef } from 'material-react-table';
3import { citiesList, data, Person, usStateList } from './makeData';
4
5const Example: FC = () => {
6  const columns = useMemo<MRT_ColumnDef<Person>[]>(
7    () => [
8      {
9        header: 'Account Status',
10        accessorFn: (originalRow) => (originalRow.isActive ? 'true' : 'false'), //must be strings
11        id: 'isActive',
12        filterVariant: 'checkbox',
13        Cell: ({ cell }) =>
14          cell.getValue() === 'true' ? 'Active' : 'Inactive',
15        size: 220,
16      },
17      {
18        accessorKey: 'name',
19        header: 'Name',
20        filterVariant: 'text', // default
21      },
22      {
23        accessorKey: 'age',
24        header: 'Age',
25        filterVariant: 'range',
26        filterFn: 'betweenInclusive', // use betweenInclusive instead of between
27      },
28      {
29        accessorKey: 'city',
30        header: 'City',
31        filterVariant: 'select',
32        filterSelectOptions: citiesList,
33      },
34      {
35        accessorKey: 'state',
36        header: 'State',
37        filterVariant: 'multi-select',
38        filterSelectOptions: usStateList,
39      },
40    ],
41    [],
42  );
43
44  return (
45    <MaterialReactTable
46      columns={columns}
47      data={data}
48      initialState={{ showColumnFilters: true }}
49    />
50  );
51};
52
53export default Example;
54

1import React, { FC, useMemo } from 'react';
2import MaterialReactTable, { MRT_ColumnDef } from 'material-react-table';
3import { MenuItem } from '@mui/material';
4import { data, Person } from './makeData';
5
6const Example: FC = () => {
7  const columns = useMemo<MRT_ColumnDef<Person>[]>(
8    () => [
9      {
10        accessorKey: 'id',
11        enableColumnFilterModes: false, //disable changing filter mode for this column
12        filterFn: 'equals', //set filter mode to equals
13        header: 'ID',
14      },
15      {
16        accessorKey: 'firstName', //normal, all filter modes are enabled
17        header: 'First Name',
18      },
19      {
20        accessorKey: 'middleName',
21        enableColumnFilterModes: false, //disable changing filter mode for this column
22        filterFn: 'startsWith', //even though changing the mode is disabled, you can still set the default filter mode
23        header: 'Middle Name',
24      },
25      {
26        accessorKey: 'lastName',
27        header: 'Last Name',
28        //if you don't want to use the default filter modes, you can provide your own and render your own menu
29        renderColumnFilterModeMenuItems: ({ onSelectFilterMode }) => [
30          <MenuItem key="0" onClick={() => onSelectFilterMode('contains')}>
31            <div>Contains</div>
32          </MenuItem>,
33          <MenuItem
34            key="1"
35            onClick={() => onSelectFilterMode('customFilterFn')}
36          >
37            <div>Custom Filter Fn</div>
38          </MenuItem>,
39        ],
40      },
41      {
42        accessorKey: 'age',
43        columnFilterModeOptions: ['between', 'greaterThan', 'lessThan'], //only allow these filter modes
44        filterFn: 'between',
45        header: 'Age',
46      },
47    ],
48    [],
49  );
50
51  return (
52    <MaterialReactTable
53      columns={columns}
54      data={data}
55      enableColumnFilterModes //enable changing filter mode for all columns unless explicitly disabled in a column def
56      initialState={{ showColumnFilters: true }} //show filters by default
57      filterFns={{
58        customFilterFn: (row, id, filterValue) => {
59          return row.getValue(id) === filterValue;
60        },
61      }}
62      localization={
63        {
64          filterCustomFilterFn: 'Custom Filter Fn',
65        } as any
66      }
67    />
68  );
69};
70
71export default Example;
72

1import React, { FC, useEffect, useMemo, useState } from 'react';
2import MaterialReactTable, { MRT_ColumnDef } from 'material-react-table';
3import type {
4  ColumnFiltersState,
5  PaginationState,
6  SortingState,
7} from '@tanstack/react-table';
8
9type UserApiResponse = {
10  data: Array<User>;
11  meta: {
12    totalRowCount: number;
13  };
14};
15
16type User = {
17  firstName: string;
18  lastName: string;
19  address: string;
20  state: string;
21  phoneNumber: string;
22};
23
24const Example: FC = () => {
25  const [data, setData] = useState<User[]>([]);
26  const [isError, setIsError] = useState(false);
27  const [isLoading, setIsLoading] = useState(false);
28  const [isRefetching, setIsRefetching] = useState(false);
29  const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
30  const [globalFilter, setGlobalFilter] = useState('');
31  const [sorting, setSorting] = useState<SortingState>([]);
32  const [pagination, setPagination] = useState<PaginationState>({
33    pageIndex: 0,
34    pageSize: 10,
35  });
36  const [rowCount, setRowCount] = useState(0);
37
38  //if you want to avoid useEffect, look at the React Query example instead
39  useEffect(() => {
40    const fetchData = async () => {
41      if (!data.length) {
42        setIsLoading(true);
43      } else {
44        setIsRefetching(true);
45      }
46
47      const url = new URL(
48        '/api/data',
49        process.env.NODE_ENV === 'production'
50          ? 'https://www.material-react-table.com'
51          : 'http://localhost:3000',
52      );
53      url.searchParams.set(
54        'start',
55        `${pagination.pageIndex * pagination.pageSize}`,
56      );
57      url.searchParams.set('size', `${pagination.pageSize}`);
58      url.searchParams.set('filters', JSON.stringify(columnFilters ?? []));
59      url.searchParams.set('globalFilter', globalFilter ?? '');
60      url.searchParams.set('sorting', JSON.stringify(sorting ?? []));
61
62      try {
63        const response = await fetch(url.href);
64        const json = (await response.json()) as UserApiResponse;
65        setData(json.data);
66        setRowCount(json.meta.totalRowCount);
67      } catch (error) {
68        setIsError(true);
69        console.error(error);
70        return;
71      }
72      setIsError(false);
73      setIsLoading(false);
74      setIsRefetching(false);
75    };
76    fetchData();
77    // eslint-disable-next-line react-hooks/exhaustive-deps
78  }, [
79    columnFilters,
80    globalFilter,
81    pagination.pageIndex,
82    pagination.pageSize,
83    sorting,
84  ]);
85
86  const columns = useMemo<MRT_ColumnDef<User>[]>(
87    () => [
88      {
89        accessorKey: 'firstName',
90        header: 'First Name',
91      },
92      //column definitions...
93      {
94        accessorKey: 'lastName',
95        header: 'Last Name',
96      },
97      {
98        accessorKey: 'address',
99        header: 'Address',
100      },
101      {
102        accessorKey: 'state',
103        header: 'State',
104      },
105      {
106        accessorKey: 'phoneNumber',
107        header: 'Phone Number',
108      },
109      
110    ],
111    [],
112  );
113
114  return (
115    <MaterialReactTable
116      columns={columns}
117      data={data}
118      enableRowSelection
119      getRowId={(row) => row.phoneNumber}
120      initialState={{ showColumnFilters: true }}
121      manualFiltering
122      manualPagination
123      manualSorting
124      muiToolbarAlertBannerProps={
125        isError
126          ? {
127              color: 'error',
128              children: 'Error loading data',
129            }
130          : undefined
131      }
132      onColumnFiltersChange={setColumnFilters}
133      onGlobalFilterChange={setGlobalFilter}
134      onPaginationChange={setPagination}
135      onSortingChange={setSorting}
136      rowCount={rowCount}
137      state={{
138        columnFilters,
139        globalFilter,
140        isLoading,
141        pagination,
142        showAlertBanner: isError,
143        showProgressBars: isRefetching,
144        sorting,
145      }}
146    />
147  );
148};
149
150export default Example;
151

1import React, { FC, useMemo } from 'react';
2import MaterialReactTable, { MRT_ColumnDef } from 'material-react-table';
3
4export type Person = {
5  id: number;
6  firstName: string;
7  lastName: string;
8  gender: string;
9  age: number;
10};
11
12const Example: FC = () => {
13  const columns = useMemo<MRT_ColumnDef<Person>[]>(
14    () => [
15      {
16        accessorKey: 'id',
17        header: 'ID',
18        muiTableHeadCellFilterTextFieldProps: { placeholder: 'ID' },
19      },
20      {
21        accessorKey: 'firstName',
22        header: 'First Name',
23      },
24      {
25        accessorKey: 'lastName',
26        header: 'Last Name',
27      },
28      {
29        accessorKey: 'gender',
30        header: 'Gender',
31        filterFn: 'equals',
32        filterSelectOptions: [
33          { text: 'Male', value: 'Male' },
34          { text: 'Female', value: 'Female' },
35          { text: 'Other', value: 'Other' },
36        ],
37        filterVariant: 'select',
38      },
39      {
40        accessorKey: 'age',
41        header: 'Age',
42        filterVariant: 'range',
43      },
44    ],
45    [],
46  );
47
48  const data = useMemo<Person[]>(
49    //data definitions...
50    () => [
51      {
52        id: 1,
53        firstName: 'Hugh',
54        lastName: 'Mungus',
55        gender: 'Male',
56        age: 42,
57      },
58      {
59        id: 2,
60        firstName: 'Leroy',
61        lastName: 'Jenkins',
62        gender: 'Male',
63        age: 51,
64      },
65      {
66        id: 3,
67        firstName: 'Candice',
68        lastName: 'Nutella',
69        gender: 'Female',
70        age: 27,
71      },
72      {
73        id: 4,
74        firstName: 'Micah',
75        lastName: 'Johnson',
76        gender: 'Other',
77        age: 32,
78      },
79    ],
80    [],
81    
82  );
83
84  return (
85    <MaterialReactTable
86      columns={columns}
87      data={data}
88      initialState={{ showColumnFilters: true }} //show filters by default
89      muiTableHeadCellFilterTextFieldProps={{
90        sx: { m: '0.5rem 0', width: '100%' },
91        variant: 'outlined',
92      }}
93    />
94  );
95};
96
97export default Example;
98