npm - material-react-table-narender - Versions diffs - 1.0.0 - Mend

material-react-table-narender 1.0.0

Files changed (1769) hide show

package/apps/material-react-table-docs/pages/docs/guides/async-loading.mdx ADDED Viewed

@@ -0,0 +1,155 @@
+import Head from 'next/head';
+import TableOptionsTable from '../../../components/prop-tables/TableOptionsTable';
+import StateOptionsTable from '../../../components/prop-tables/StateOptionsTable';
+import LoadingExample from '../../../examples/loading';
+import LinearProgressExample from '../../../examples/linear-progress';
+import ReactQueryExample from '../../../examples/react-query';
+<Head>
+  <title>{'Async Loading UI Guide - Material React Table V3 Docs'}</title>
+  <meta
+    name="description"
+    content="How to show loading indicators, skeletons, and progress bars in Material React Table"
+  />
+</Head>
+## Async Loading UI Feature Guide
+While you are fetching your data, you may want to show some loading indicators. Material React Table has some nice loading UI features built in that look better than a simple spinner.
+> This guide is mostly focused on the loading UI features. Make sure to also check out the [Remote Data](/docs/examples/remote) and [React Query](/docs/examples/react-query) examples for server-side logic examples.
+### Relevant Table Options
+<TableOptionsTable
+  onlyOptions={
+    new Set([
+      'muiSkeletonProps',
+      'muiLinearProgressProps',
+      'muiCircularProgressProps',
+    ])
+  }
+/>
+### Relevant State Options
+<StateOptionsTable
+  onlyOptions={
+    new Set([
+      'isLoading',
+      'isSaving',
+      'showLoadingOverlay',
+      'showProgressBars',
+      'showSkeletons',
+    ])
+  }
+/>
+### isLoading UI
+There are three different loading UI features that are built into Material React Table:
+1. Loading Overlay - shows spinner overlay over the table container.
+2. Cell Skeletons - show pretty and shimmering skeletons for each cell.
+3. Linear Progress Bars - shows progress bars above and/or below the table.
+You can use any combination of these loading UIs by managing the `showLoadingOverlay`, `showSkeletons`, and `showProgressBars` states.
+There are also two other loading states that are shortcuts for combining some of the above states:
+- `isLoading` - shows loading overlay and cell skeletons.
+- `isSaving` - shows the progress bars and adds spinners to the save buttons in editing features.
+Here is some of the recommended loading UI that you might use with React Query:
+```jsx
+const {
+  data = [],
+  isLoading: isLoadingTodos,
+  isRefetching: isRefetchingTodos,
+} = useQuery({
+  /**/
+});
+const { mutate, isPending: isSavingTodos } = useMutation({
+  /**/
+});
+const table = useMaterialReactTable({
+  columns,
+  data,
+  state: {
+    isLoading: isLoadingTodos, //cell skeletons and loading overlay
+    showProgressBars: isRefetchingTodos, //progress bars while refetching
+    isSaving: isSavingTodos, //progress bars and save button spinners
+  },
+});
+return <MaterialReactTable table={table} />;
+```
+> Note: The Loading Overlay UI makes the table container non-interactive while it is showing. This is usually desired while no data is yet in the table. Consider avoiding using the Loading Overlay UI during "refetching" operations like filtering, sorting, or pagination.
+### Customize Loading UI
+You can customize the loading UI by passing props to the `muiSkeletonProps`, `muiLinearProgressProps`, and `muiCircularProgressProps` props.
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  muiSkeletonProps: {
+    animation: 'wave',
+  },
+  muiLinearProgressProps: {
+    color: 'secondary',
+  },
+  muiCircularProgressProps: {
+    color: 'secondary',
+  },
+});
+return <MaterialReactTable table={table} />;
+```
+<LoadingExample />
+#### Custom Loading Spinner component
+> New in v2.11.0
+If you need to use a custom loading spinner component other than the built-in MUI one, you can now pass in custom component in the `muiCircularProgressProps` `Component` prop.
+```jsx
+import { MyCustomSpinner } from './MyCustomSpinner';
+const table = useMaterialReactTable({
+  columns,
+  data,
+  muiCircularProgressProps: {
+    Component: <MyCustomSpinner />,
+  },
+});
+```
+### Only Show Progress Bars or Skeletons
+If you do not want both progress bars and cell skeletons to show, you can use the `showProgressBars` and `showSkeletons` states, instead.
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  state: {
+    showProgressBars: true, //or showSkeletons
+  },
+});
+```
+<LinearProgressExample />
+### Full Loading and Server-Side Logic Example
+Here is a copy of the full [React Query](/docs/examples/react-query) example.
+<ReactQueryExample />

package/apps/material-react-table-docs/pages/docs/guides/best-practices.mdx ADDED Viewed

@@ -0,0 +1,373 @@
+import Head from 'next/head';
+<Head>
+  <title>{'Best Practices (TypeScript) - Material React Table V3 Docs'}</title>
+  <meta
+    name="description"
+    content="The Best Practices to follow with TypeScript when using Material React Table."
+  />
+</Head>
+## MRT Best Practices
+Here are some best practices to follow when using Material React Table. We'll cover Type-Safety (even if you are not using TypeScript) and how to best create re-usable MRT components.
+### Stay Up-To-Date
+Run this command in your terminal every few weeks to make sure you are using the latest version of Material React Table and MUI
+```bash
+npx npm-check-updates -u material-react-table @mui/material @mui/x-date-pickers @mui/icons-material @emotion/react @emotion/styled
+```
+### Type-Safety
+TanStack Table itself is written in TypeScript, and Material React Table builds on top of its great type definitions for a best-in-class TypeScript experience.
+If, however, you cannot use TypeScript in your project for some reason, checkout down below for [how to use JSDoc instead of TypeScript](#use-jsdoc-instead-of-typescript) to get the same type hints.
+#### Is TypeScript Required?
+No, TypeScript is not required to use Material React Table. You can just use JavaScript and everything will work just fine, but you will be missing out on a lot of great type hints and type safety that can help you build your app faster and with less bugs.
+There are a couple of ways to still get type hints without TypeScript with the [`createMRTColumnHelper`](#createmrtcolumnhelper-utility) utility function or by using [JSDoc](#use-jsdoc-instead-of-typescript), so you can still get some of the benefits of type safety without TypeScript.
+#### Defining TData Type
+Material React Table makes use of generics to make working with your specific row data structures easier. You will see that most of the `MRT_*` types that you can use accept a `TData` generic.
+Let's say that the data in your table is an array of users that looks like this:
+```tsx
+const data: User[] = [
+  { id: 1, name: 'John', age: 23 },
+  { id: 2, name: 'Alice', age: 17 },
+  { id: 3, name: 'Bob', age: 32 },
+];
+```
+Then your `TData` type can be defined as:
+```tsx
+export type User = {
+  id: number;
+  name: string;
+  age: number;
+};
+```
+You will often pass this `TData` type as a generic to the `MRT_*` types that you use so that you can get type hints for your specific data structure.
+#### Define Your Columns With Type-Safety
+Material React Table provides a couple of ways to define your columns with type safety. You can either simply use the `MRT_ColumnDef` type or use the new `createMRTColumnHelper` utility function.
+#### MRT_ColumnDef Type
+The most straightforward way to define your columns with type-safety is to just type your columns as `Array<MRT_ColumnDef<TData>>`.
+```tsx
+import {
+  MaterialReactTable,
+  useMaterialReactTable,
+  type MRT_ColumnDef, // <--- import MRT_ColumnDef
+} from 'material-react-table';
+import { type User } from './types'; // <--- import your TData type from wherever you defined it
+// define your columns, pass User as a generic to MRT_ColumnDef
+const columns: Array<MRT_ColumnDef<User>> = [
+  {
+    accessorKey: 'id', //you should get type hints for all of your keys if you defined your TData type correctly
+    header: 'ID',
+    enableSorting: false, //you should get type hints for all possible column options that you can define here
+  },
+  {
+    accessorKey: 'name',
+    header: 'Name',
+  },
+  {
+    accessorFn: (originalRow) => Number(originalRow.age), //you should also get type hints for your accessorFn
+    header: 'Age',
+    Cell: ({ cell }) => <span>{cell.getValue<number>()}</span>, //cell.getValue() will be typed as `unknown` by default, but you can pass a generic to get the correct type
+    //see the createMRTColumnHelper example below for a better way to get type safety with cell.getValue()
+  },
+];
+```
+#### createMRTColumnHelper Utility
+> New in V3 (After many requests)
+Alternatively you can use the `createMRTColumnHelper` utility function to define your columns. This works the same way as the TanStack `createColumnHelper`.
+Additional `TValue` type-safety is provided by using this utility. That means that when you call `cell.getValue()` in either a custom `Cell` render, or in any of the `mui*Props`, you will get the correct type for the data in that column instead of `unknown`.
+```tsx
+import {
+  MaterialReactTable,
+  useMaterialReactTable,
+  createMRTColumnHelper, // <--- import createMRTColumnHelper
+} from 'material-react-table';
+import { type User } from './types'; // <--- import your TData type from wherever you defined it (if using TS)
+const columnHelper = createMRTColumnHelper<User>(); // <--- pass your TData type as a generic to createMRTColumnHelper (if using TS)
+//columns will be inferred as Array<MRT_ColumnDef<User>>
+const columns = [
+  //accessorKey as first argument, rest of column options as second argument
+  columnHelper.accessor('name', {
+    header: 'Last Name',
+  }),
+  //accessorFn as first argument, rest of column options as second argument
+  columnHelper.accessor((row) => Number(row.age), {
+    id; 'age', //id required for accessorFn
+    header: 'Age',
+    filterVariant: 'range-slider', //you should get type hints for all possible column options that you can define here
+    Cell: ({ cell }) => <span>{cell.getValue()}</span>, //cell.getValue() will be typed as number instead of unknown
+  }),
+  //display column (no accessor needed)
+  columnHelper.display({
+    header: 'Contact',
+    Cell: ({ row }) => (
+      <Button onClick={() => sendEmail(row.original.email)}>Send Email</Button>
+    ),
+  }),
+];
+```
+#### Use JSDoc instead of TypeScript
+If you are in a situation where you are not able to install TypeScript in your project, you can technically do the same thing as up above in JavaScript using JSDoc.
+```jsx
+import {
+  MaterialReactTable,
+  useMaterialReactTable,
+} from 'material-react-table';
+//define TData type with JSDoc
+/**
+ * @typedef {Object} User
+ * @property {number} id
+ * @property {string} name
+ * @property {number} age
+ */
+//import MRT_ColumnDef type with JSDoc
+/**
+ * @type {import('material-react-table').MRT_ColumnDef<User>[]}
+ */
+const columns = [
+  {
+    accessorKey: 'id', //you should get type hints for all of your keys if you defined your TData type correctly
+    header: 'ID',
+    enableSorting: false, //you should get type hints for all possible column options that you can define here
+  },
+  {
+    accessorKey: 'name',
+    header: 'Name',
+  },
+  {
+    accessorFn: (originalRow) => Number(originalRow.age), //you should also get type hints for your accessorFn
+    header: 'Age',
+  },
+];
+```
+### Re-Usable MRT Components
+If you are going to have multiple tables in your app, chances are that you will want to make a re-usable component built on top of Material React Table. This is a good idea and good practice, but here are a few suggestions to maintain type safety with some TypeScript generics.
+#### Re-usable Components or Options?
+In my opinion, instead of creating a re-usable component, it is instead actually best to define your default options and share them between all of your tables.
+##### Re-usable Default Options
+In this example, we are simply creating a factory function that creates all of the default options that you want all of your tables to start with.
+```ts
+import { type MRT_RowData, type MRT_TableOptions } from 'material-react-table';
+//define re-useable default table options for all tables in your app
+export const getDefaultMRTOptions = <TData extends MRT_RowData>(): Partial<
+  MRT_TableOptions<TData>
+> => ({
+  //list all of your default table options here
+  enableGlobalFilter: false,
+  enableRowPinning: true,
+  initialState: { showColumnFilters: true },
+  manualFiltering: true,
+  manualPagination: true,
+  manualSorting: true,
+  muiTableHeadCellProps: {
+    sx: { fontSize: '1.1rem' },
+  },
+  paginationDisplayMode: 'pages',
+  //etc...
+  defaultColumn: {
+    //you can even list default column options here
+  },
+});
+```
+Then you can use these options in every new table that you create:
+```tsx
+import {
+  MaterialReactTable,
+  useMaterialReactTable,
+  type MRT_ColumnDef,
+} from 'material-react-table';
+import { getDefaultMRTOptions } from './utils'; //your default options
+interface User {
+  id: number;
+  name: string;
+  age: number;
+}
+const defaultMRTOptions = getDefaultMRTOptions<User>(); //get your default options
+export const OneOfYourTableComponents = () => {
+  const columns: MRT_ColumnDef<User>[] = [
+    //...
+  ];
+  const { data } = useQuery({
+    //...
+  });
+  const table = useMaterialReactTable({
+    ...defaultMRTOptions, //spread your default options
+    columns,
+    data,
+    enableGlobalFilter: true, //override default options
+    initialState: {
+      ...defaultMRTOptions.initialState, //spread default initial state
+      showColumnFilters: false, //override default initial state for just this table
+    },
+    //...
+  });
+  //you will have access to the entire table instance where you need it
+  console.log(table.getState());
+  return <MaterialReactTable table={table} />;
+};
+```
+Doing it this way, you maintain 100% control of your table instance and any state that you are managing in each table component.
+I believe this is by far the best way to work with Material React Table in your application code, and how I personally use it in my own apps.
+##### Re-usable MRT Component
+If you still want to just create a re-usable MRT component instead, you can do that too, of course. Here is a type-safe way to do that:
+```tsx
+import {
+  MaterialReactTable,
+  useMaterialReactTable,
+  type MRT_ColumnDef,
+  type MRT_RowData, //default shape of TData (Record<string, any>)
+  type MRT_TableOptions,
+} from 'material-react-table';
+interface Props<TData extends MRT_RowData> extends MRT_TableOptions<TData> {
+  columns: MRT_ColumnDef<TData>[];
+  data: TData[];
+}
+export const CustomMRTTable = <TData extends MRT_RowData>({
+  columns,
+  data,
+  ...rest
+}: Props<TData>) => {
+  const table = useMaterialReactTable({
+    columns,
+    data,
+    //your custom table options...
+    ...rest, //accept props to override default table options
+  });
+  return <MaterialReactTable table={table} />;
+};
+```
+By using the `TData` generic correctly, you can maintain type-safety in your re-usable component that will adapt to different types of data you will have throughout your application.
+Though, be aware that the weakness of this approach is that it will be more annoying to get access to the `table` instance or read table state where you need it.
+When re-using your MRT table component, it will just look something like this:
+```tsx
+import { CustomMRTTable } from './CustomMRTTable';
+const columns: MRT_ColumnDef<User>[] = [
+  //...
+];
+export const YourComponent = () => {
+  //no easy access to the table instance or table state here unless you manage all of the state in this component
+  const [pagination, setPagination] = useState<MRT_PaginationState>({
+    pageIndex: 0,
+    pageSize: 10,
+  });
+  const [sorting, setSorting] = useState<MRT_SortingState[]>([]);
+  //etc...
+  const { data } = useQuery({
+    //...
+  });
+  return (
+    <CustomMRTTable
+      columns={columns}
+      data={data}
+      enableRowPinning
+      //manage states to get access to them
+      onPaginationChange={setPagination}
+      onSortingChange={setSorting}
+      //etc...
+      state={{
+        pagination,
+        sorting,
+        //etc...
+      }}
+    />
+  );
+};
+```
+### Debugging Material React Table
+Material React Table _(though really TanStack Table)_ can be a lot easier to debug than other data grid libraries. This is because you are often in charge of the state that you care about, and the entire table instance is available to you in your own scope if you are using the `useMaterialReactTable` hook. There are also some advanced TanStack Table Dev Tools that you can optionally install.
+#### Console Logging from the Table Instance
+When in doubt, console log it! There are a lot of things you can easily console log. Here are some examples:
+##### Console Log All Internal Table State
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  //** */
+});
+console.log(table.getState());
+```
+##### Console Log Current Rendering Rows
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  //** */
+});
+console.log(table.getRowModel().rows);
+```

package/apps/material-react-table-docs/pages/docs/guides/cell-actions.mdx ADDED Viewed

@@ -0,0 +1,161 @@
+import Head from 'next/head';
+import TableOptionsTable from '../../../components/prop-tables/TableOptionsTable';
+import ColumnOptionsTable from '../../../components/prop-tables/ColumnOptionsTable';
+import EnableExample from '../../../examples/enable-cell-actions';
+<Head>
+  <title>{'Cell Actions Guide - Material React Table V3 Docs'}</title>
+  <meta
+    name="description"
+    content="How to add cell action context menus to each cell in Material React Table"
+  />
+</Head>
+## Cell Actions Feature Guide
+> New in v2.10.0
+Material React Table provides you an easy shell to render a context menu for when a table cell/row is right clicked or otherwise activated. This is useful for providing additional actions that can be performed on a cell or row.
+### Relevant Table Options
+<TableOptionsTable
+  onlyOptions={
+    new Set([
+      'enableCellActions',
+      'enableClickToCopy',
+      'renderCellActionMenuItems',
+    ])
+  }
+/>
+### Relevant Column Options
+<ColumnOptionsTable
+  onlyOptions={
+    new Set([
+      'enableCellActions',
+      'enableClickToCopy',
+      'renderCellActionMenuItems',
+    ])
+  }
+/>
+### Enable Cell Actions
+To enable cell actions, you need to set the `enableCellActions` option to `true` for the cells that you want to have access to the context menu. This can be done at the table level or at the column level, and accepts a boolean or a function that returns a boolean.
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  enableCellActions: true,
+  //or
+  enableCellActions: (cell) => (cell.row.original.someCondition ? true : false),
+});
+```
+### Render Cell Action Menu Items
+The cell actions context menu will only appear if there are items to display. You can provide the `renderCellActionMenuItems` table option or column option to render the appropriate items in the context menu for each cell.
+MRT also provides a `MRT_ActionMenuItem` component that you can use to render the menu items. This just a wrapper for the MUI MenuItem component that also provides consistent CSS for styling the icons, spacing, and optional sub-menu items. Use it if you want to have a consistent look and feel with all of the other built-in MRT Menus.
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  enableCellActions: true,
+  renderCellActionMenuItems: ({ closeMenu, cell, row, table }) => [
+    //array required
+    <MRT_ActionMenuItem //or just use the normal MUI MenuItem
+      icon={<Email />}
+      key={1}
+      label="Item 1"
+      onClick={() => {
+        //your logic here
+        closeMenu(); //close the menu after the action is performed
+      }}
+      table={table}
+    />,
+    <MRT_ActionMenuItem
+      icon={<PersonOffOutlined />}
+      key={2}
+      label="Item 2"
+      onClick={async () => {
+        //await your logic here
+        closeMenu(); //close the menu after the async action is performed
+      }}
+      table={table}
+    />,
+  ],
+});
+```
+### Include Automatic Cell Actions
+A few cell actions are included by default when certain other features are enabled.
+- A "Copy" action will be included when the `enableClickToCopy` option is set to `"context-menu"` (instead of `true`) for the table or column.
+- An "Edit" action will be included when the `enableEditing` option is set to `true` and the `editDisplayMode` option is set to `"cell"`. This will not disable the default double-click to edit behavior, but will provide an additional way to edit the cell.
+More built-in cell actions may be added in the future.
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  enableCellActions: true,
+  enableClickToCopy: 'context-menu',
+  enableEditing: true,
+  editDisplayMode: 'cell',
+});
+```
+If you want to render these actions alongside your custom actions, you will just need to include the `internalMenuItems` parameter in your `renderCellActionMenuItems` function.
+```jsx
+const table = useMaterialReactTable({
+  columns,
+  data,
+  enableCellActions: true,
+  enableClickToCopy: 'context-menu',
+  enableEditing: true,
+  editDisplayMode: 'cell',
+  renderCellActionMenuItems: ({
+    closeMenu,
+    cell,
+    row,
+    table,
+    internalMenuItems,
+  }) => [
+    ...internalMenuItems, //render the copy and edit actions wherever you want in the list
+    <Divider />, //optionally place a Menu Divider to separate groups of actions
+    <MRT_ActionMenuItem
+      icon={<Email />}
+      key={1}
+      label="Item 1"
+      onClick={() => {
+        //your logic here
+        closeMenu(); //close the menu after the action is performed
+      }}
+      table={table}
+    />,
+    <MRT_ActionMenuItem
+      icon={<PersonOffOutlined />}
+      key={2}
+      label="Item 2"
+      onClick={async () => {
+        //await your logic here
+        closeMenu(); //close the menu after the async action is performed
+      }}
+      table={table}
+    />,
+  ],
+});
+```
+<EnableExample />
+View Extra Storybook **[Examples](https://www.material-react-table.dev/?path=/story/features-cell-action-examples)**