@novastera-oss/material-react-table 4.0.0-beta.11

package/src/components/inputs/MRT_GlobalFilterTextField.tsx

@@ -0,0 +1,165 @@
+import {
+  type ChangeEvent,
+  type MouseEvent,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+} from 'react';
+import Collapse from '@mui/material/Collapse';
+import IconButton from '@mui/material/IconButton';
+import InputAdornment from '@mui/material/InputAdornment';
+import TextField, { type TextFieldProps } from '@mui/material/TextField';
+import Tooltip from '@mui/material/Tooltip';
+import { debounce } from '@mui/material/utils';
+import { type MRT_RowData, type MRT_TableInstance } from '../../types';
+import { parseFromValuesOrFunc, resolveSlotProps } from '../../utils/utils';
+import { MRT_FilterOptionMenu } from '../menus/MRT_FilterOptionMenu';
+
+export interface MRT_GlobalFilterTextFieldProps<TData extends MRT_RowData>
+  extends TextFieldProps<'standard'> {
+  table: MRT_TableInstance<TData>;
+}
+
+export const MRT_GlobalFilterTextField = <TData extends MRT_RowData>({
+  table,
+  ...rest
+}: MRT_GlobalFilterTextFieldProps<TData>) => {
+  const {
+    getState,
+    options: {
+      enableGlobalFilterModes,
+      icons: { CloseIcon, SearchIcon },
+      localization,
+      manualFiltering,
+      muiSearchTextFieldProps,
+    },
+    refs: { searchInputRef },
+    setGlobalFilter,
+  } = table;
+  const { globalFilter, showGlobalFilter } = getState();
+
+  const {
+    InputProps: muiInputProps,
+    inputProps: muiHtmlInputProps,
+    slotProps: muiSlotProps,
+    ...textFieldProps
+  } = {
+    ...parseFromValuesOrFunc(muiSearchTextFieldProps, {
+      table,
+    }),
+    ...rest,
+  } as any;
+
+  const isMounted = useRef(false);
+  const [anchorEl, setAnchorEl] = useState<HTMLElement | null>(null);
+  const [searchValue, setSearchValue] = useState(globalFilter ?? '');
+
+  const handleChangeDebounced = useCallback(
+    debounce(
+      (event: ChangeEvent<HTMLInputElement>) => {
+        setGlobalFilter(event.target.value ?? undefined);
+      },
+      manualFiltering ? 500 : 250,
+    ),
+    [],
+  );
+
+  const handleChange = (event: ChangeEvent<HTMLInputElement>) => {
+    setSearchValue(event.target.value);
+    handleChangeDebounced(event);
+    (textFieldProps as any)?.onChange?.(event);
+  };
+
+  const handleGlobalFilterMenuOpen = (event: MouseEvent<HTMLElement>) => {
+    setAnchorEl(event.currentTarget);
+  };
+
+  const handleClear = () => {
+    setSearchValue('');
+    setGlobalFilter(undefined);
+  };
+
+  useEffect(() => {
+    if (isMounted.current) {
+      setSearchValue(globalFilter ?? '');
+    }
+    isMounted.current = true;
+  }, [globalFilter]);
+
+  return (
+    <Collapse in={showGlobalFilter} orientation="horizontal">
+      <TextField
+        fullWidth
+        margin="none"
+        placeholder={localization.search}
+        variant="standard"
+        {...textFieldProps}
+        slotProps={{
+          ...muiSlotProps,
+          htmlInput: (ownerState: any) =>
+            resolveSlotProps(
+              muiSlotProps?.htmlInput,
+              { autoComplete: 'off', ...muiHtmlInputProps },
+              ownerState,
+            ),
+          input: (ownerState: any) =>
+            resolveSlotProps(
+              muiSlotProps?.input,
+              {
+                endAdornment: (
+                  <InputAdornment position="end">
+                    <Tooltip title={localization.clearSearch ?? ''}>
+                      <span>
+                        <IconButton
+                          aria-label={localization.clearSearch}
+                          disabled={!searchValue?.length}
+                          onClick={handleClear}
+                          size="small"
+                        >
+                          <CloseIcon />
+                        </IconButton>
+                      </span>
+                    </Tooltip>
+                  </InputAdornment>
+                ),
+                startAdornment: enableGlobalFilterModes ? (
+                  <InputAdornment position="start">
+                    <Tooltip title={localization.changeSearchMode}>
+                      <IconButton
+                        aria-label={localization.changeSearchMode}
+                        onClick={handleGlobalFilterMenuOpen}
+                        size="small"
+                        sx={{ height: '1.75rem', width: '1.75rem' }}
+                      >
+                        <SearchIcon />
+                      </IconButton>
+                    </Tooltip>
+                  </InputAdornment>
+                ) : (
+                  <SearchIcon style={{ marginRight: '4px' }} />
+                ),
+                sx: { mb: 0 },
+                ...muiInputProps,
+              },
+              ownerState,
+            ),
+        }}
+        inputRef={(inputRef) => {
+          searchInputRef.current = inputRef;
+          if ((textFieldProps as any)?.inputRef) {
+            (textFieldProps as any).inputRef = inputRef;
+          }
+        }}
+        onChange={handleChange}
+        value={searchValue ?? ''}
+      />
+      <MRT_FilterOptionMenu
+        anchorEl={anchorEl}
+        onSelect={handleClear}
+        setAnchorEl={setAnchorEl}
+        table={table}
+      />
+    </Collapse>
+  );
+};

package/src/components/inputs/MRT_SelectCheckbox.tsx

@@ -0,0 +1,142 @@
+import { type ChangeEvent, type MouseEvent } from 'react';
+import Checkbox, { type CheckboxProps } from '@mui/material/Checkbox';
+import Radio, { type RadioProps } from '@mui/material/Radio';
+import Tooltip from '@mui/material/Tooltip';
+import { type Theme } from '@mui/material/styles';
+import {
+  type MRT_Row,
+  type MRT_RowData,
+  type MRT_TableInstance,
+} from '../../types';
+import {
+  getIsRowSelected,
+  getMRT_RowSelectionHandler,
+  getMRT_SelectAllHandler,
+} from '../../utils/row.utils';
+import { getCommonTooltipProps } from '../../utils/style.utils';
+import { parseFromValuesOrFunc } from '../../utils/utils';
+
+export interface MRT_SelectCheckboxProps<TData extends MRT_RowData>
+  extends CheckboxProps {
+  row?: MRT_Row<TData>;
+  staticRowIndex?: number;
+  table: MRT_TableInstance<TData>;
+}
+
+export const MRT_SelectCheckbox = <TData extends MRT_RowData>({
+  row,
+  staticRowIndex,
+  table,
+  ...rest
+}: MRT_SelectCheckboxProps<TData>) => {
+  const {
+    getState,
+    options: {
+      enableMultiRowSelection,
+      localization,
+      muiSelectAllCheckboxProps,
+      muiSelectCheckboxProps,
+      selectAllMode,
+    },
+  } = table;
+  const { density, isLoading } = getState();
+
+  const selectAll = !row;
+
+  const allRowsSelected = selectAll
+    ? selectAllMode === 'page'
+      ? table.getIsAllPageRowsSelected()
+      : table.getIsAllRowsSelected()
+    : undefined;
+
+  const isChecked = selectAll
+    ? allRowsSelected
+    : getIsRowSelected({ row, table });
+
+  const {
+    inputProps: muiInputProps,
+    slotProps: muiSlotProps,
+    ...checkboxProps
+  } = ((selectAll
+    ? parseFromValuesOrFunc(muiSelectAllCheckboxProps, { table })
+    : parseFromValuesOrFunc(muiSelectCheckboxProps, {
+      row,
+      staticRowIndex,
+      table,
+    })) ?? {}) as any;
+
+  const onSelectionChange = row
+    ? getMRT_RowSelectionHandler({
+      row,
+      staticRowIndex,
+      table,
+    })
+    : undefined;
+
+  const onSelectAllChange = getMRT_SelectAllHandler({ table });
+
+  const commonProps = {
+    'aria-label': selectAll
+      ? localization.toggleSelectAll
+      : localization.toggleSelectRow,
+    checked: isChecked,
+    disabled:
+      isLoading || (row && !row.getCanSelect()) || row?.id === 'mrt-row-create',
+    slotProps: {
+      ...muiSlotProps,
+      input: {
+        'aria-label': selectAll
+          ? localization.toggleSelectAll
+          : localization.toggleSelectRow,
+        ...muiInputProps,
+        ...muiSlotProps?.input,
+      },
+    },
+    onChange: (event: ChangeEvent<HTMLInputElement>) => {
+      event.stopPropagation();
+      selectAll ? onSelectAllChange(event) : onSelectionChange!(event);
+    },
+    size: (density === 'compact' ? 'small' : 'medium') as 'medium' | 'small',
+    ...checkboxProps,
+    ...rest,
+    onClick: (e: MouseEvent<HTMLButtonElement>) => {
+      e.stopPropagation();
+      (checkboxProps as any)?.onClick?.(e);
+      rest?.onClick?.(e);
+    },
+    sx: (theme: Theme) => ({
+      height: density === 'compact' ? '1.75rem' : '2.5rem',
+      m: density !== 'compact' ? '-0.4rem' : undefined,
+      width: density === 'compact' ? '1.75rem' : '2.5rem',
+      zIndex: 0,
+      ...parseFromValuesOrFunc((checkboxProps as any)?.sx, theme),
+      ...parseFromValuesOrFunc(rest?.sx, theme),
+    }),
+    title: undefined,
+  } as unknown as CheckboxProps | RadioProps;
+
+  return (
+    <Tooltip
+      {...getCommonTooltipProps()}
+      title={
+        checkboxProps?.title ??
+        (selectAll
+          ? localization.toggleSelectAll
+          : localization.toggleSelectRow)
+      }
+    >
+      {enableMultiRowSelection === false ? (
+        <Radio {...(commonProps as any)} />
+      ) : (
+        <Checkbox
+          indeterminate={
+            !isChecked && selectAll
+              ? table.getIsSomeRowsSelected()
+              : row?.getIsSomeSelected() && row.getCanSelectSubRows()
+          }
+          {...commonProps}
+        />
+      )}
+    </Tooltip>
+  );
+};

package/src/components/menus/MRT_ActionMenuItem.tsx

@@ -0,0 +1,62 @@
+import { type ReactNode } from 'react';
+import Box from '@mui/material/Box';
+import IconButton from '@mui/material/IconButton';
+import ListItemIcon from '@mui/material/ListItemIcon';
+import MenuItem, { type MenuItemProps } from '@mui/material/MenuItem';
+import { type MRT_RowData, type MRT_TableInstance } from '../../types';
+
+export interface MRT_ActionMenuItemProps<TData extends MRT_RowData>
+  extends MenuItemProps {
+  icon: ReactNode;
+  label: string;
+  onOpenSubMenu?: MenuItemProps['onClick'] | MenuItemProps['onMouseEnter'];
+  table: MRT_TableInstance<TData>;
+}
+
+export const MRT_ActionMenuItem = <TData extends MRT_RowData>({
+  icon,
+  label,
+  onOpenSubMenu,
+  table,
+  ...rest
+}: MRT_ActionMenuItemProps<TData>) => {
+  const {
+    options: {
+      icons: { ArrowRightIcon },
+    },
+  } = table;
+
+  return (
+    <MenuItem
+      sx={{
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        minWidth: '120px',
+        my: 0,
+        py: '6px',
+      }}
+      tabIndex={0}
+      {...rest}
+    >
+      <Box
+        sx={{
+          alignItems: 'center',
+          display: 'flex',
+        }}
+      >
+        <ListItemIcon>{icon}</ListItemIcon>
+        {label}
+      </Box>
+      {onOpenSubMenu && (
+        <IconButton
+          onClick={onOpenSubMenu as any}
+          onMouseEnter={onOpenSubMenu as any}
+          size="small"
+          sx={{ p: 0 }}
+        >
+          <ArrowRightIcon />
+        </IconButton>
+      )}
+    </MenuItem>
+  );
+};

package/src/components/menus/MRT_CellActionMenu.tsx

@@ -0,0 +1,109 @@
+import Menu, { type MenuProps } from '@mui/material/Menu';
+import { MRT_ActionMenuItem } from './MRT_ActionMenuItem';
+import { type MRT_RowData, type MRT_TableInstance } from '../../types';
+import { openEditingCell } from '../../utils/cell.utils';
+import { parseFromValuesOrFunc } from '../../utils/utils';
+
+export interface MRT_CellActionMenuProps<TData extends MRT_RowData>
+  extends Partial<MenuProps> {
+  table: MRT_TableInstance<TData>;
+}
+
+export const MRT_CellActionMenu = <TData extends MRT_RowData>({
+  table,
+  ...rest
+}: MRT_CellActionMenuProps<TData>) => {
+  const {
+    getState,
+    options: {
+      editDisplayMode,
+      enableClickToCopy,
+      enableEditing,
+      icons: { ContentCopy, EditIcon },
+      localization,
+      mrtTheme: { menuBackgroundColor },
+      renderCellActionMenuItems,
+    },
+    refs: { actionCellRef },
+  } = table;
+  const { actionCell, density } = getState();
+  const cell = actionCell!;
+  const { row } = cell;
+  const { column } = cell;
+  const { columnDef } = column;
+
+  const handleClose = (event?: any) => {
+    event?.stopPropagation();
+    table.setActionCell(null);
+    actionCellRef.current = null;
+  };
+
+  const internalMenuItems = [
+    (parseFromValuesOrFunc(enableClickToCopy, cell) === 'context-menu' ||
+      parseFromValuesOrFunc(columnDef.enableClickToCopy, cell) ===
+        'context-menu') && (
+      <MRT_ActionMenuItem
+        icon={<ContentCopy />}
+        key={'mrt-copy'}
+        label={localization.copy}
+        onClick={(event) => {
+          event.stopPropagation();
+          navigator.clipboard.writeText(cell.getValue() as string);
+          handleClose();
+        }}
+        table={table}
+      />
+    ),
+    parseFromValuesOrFunc(enableEditing, row) && editDisplayMode === 'cell' && (
+      <MRT_ActionMenuItem
+        icon={<EditIcon />}
+        key={'mrt-edit'}
+        label={localization.edit}
+        onClick={() => {
+          openEditingCell({ cell, table });
+          handleClose();
+        }}
+        table={table}
+      />
+    ),
+  ].filter(Boolean);
+
+  const renderActionProps = {
+    cell,
+    closeMenu: handleClose,
+    column,
+    internalMenuItems,
+    row,
+    table,
+  };
+
+  const menuItems =
+    columnDef.renderCellActionMenuItems?.(renderActionProps) ??
+    renderCellActionMenuItems?.(renderActionProps);
+
+  return (
+    (!!menuItems?.length || !!internalMenuItems?.length) && (
+      <Menu
+        anchorEl={actionCellRef.current}
+        disableScrollLock
+        onClick={(event) => event.stopPropagation()}
+        onClose={handleClose}
+        open={!!cell}
+        slotProps={{
+          list: {
+            dense: density === 'compact',
+            sx: {
+              backgroundColor: menuBackgroundColor,
+            },
+            ...rest.slotProps?.list,
+          },
+          ...rest.slotProps,
+        }}
+        transformOrigin={{ horizontal: -100, vertical: 8 }}
+        {...rest}
+      >
+        {menuItems ?? internalMenuItems}
+      </Menu>
+    )
+  );
+};