@mui/x-data-grid 5.5.1 → 5.7.0

package/legacy/components/cell/GridCell.js

@@ -0,0 +1,220 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["align", "children", "colIndex", "cellMode", "field", "formattedValue", "hasFocus", "height", "isEditable", "rowId", "tabIndex", "value", "width", "className", "showRightBorder", "extendRowFullWidth", "row", "onClick", "onDoubleClick", "onMouseDown", "onMouseUp", "onKeyDown", "onDragEnter", "onDragOver"];
+
+/* eslint-disable jsx-a11y/no-noninteractive-element-interactions */
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import clsx from 'clsx';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { ownerDocument, capitalize } from '@mui/material/utils';
+import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { GridEvents, GridCellModes } from '../../models';
+import { useGridApiContext } from '../../hooks/utils/useGridApiContext';
+import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
+import { gridFocusCellSelector } from '../../hooks/features/focus/gridFocusStateSelector';
+import { jsx as _jsx } from "react/jsx-runtime";
+// Based on https://stackoverflow.com/a/59518678
+var cachedSupportsPreventScroll;
+
+function doesSupportPreventScroll() {
+  if (cachedSupportsPreventScroll === undefined) {
+    document.createElement('div').focus({
+      get preventScroll() {
+        cachedSupportsPreventScroll = true;
+        return false;
+      }
+
+    });
+  }
+
+  return cachedSupportsPreventScroll;
+}
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var align = ownerState.align,
+      showRightBorder = ownerState.showRightBorder,
+      isEditable = ownerState.isEditable,
+      classes = ownerState.classes;
+  var slots = {
+    root: ['cell', "cell--text".concat(capitalize(align)), isEditable && 'cell--editable', showRightBorder && 'withBorder'],
+    content: ['cellContent']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+var warnedOnce = false;
+
+function GridCell(props) {
+  var _rootProps$experiment;
+
+  var align = props.align,
+      children = props.children,
+      colIndex = props.colIndex,
+      cellMode = props.cellMode,
+      field = props.field,
+      formattedValue = props.formattedValue,
+      hasFocus = props.hasFocus,
+      height = props.height,
+      isEditable = props.isEditable,
+      rowId = props.rowId,
+      tabIndex = props.tabIndex,
+      value = props.value,
+      width = props.width,
+      className = props.className,
+      showRightBorder = props.showRightBorder,
+      extendRowFullWidth = props.extendRowFullWidth,
+      row = props.row,
+      onClick = props.onClick,
+      onDoubleClick = props.onDoubleClick,
+      onMouseDown = props.onMouseDown,
+      onMouseUp = props.onMouseUp,
+      onKeyDown = props.onKeyDown,
+      onDragEnter = props.onDragEnter,
+      onDragOver = props.onDragOver,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var valueToRender = formattedValue == null ? value : formattedValue;
+  var cellRef = React.useRef(null);
+  var apiRef = useGridApiContext();
+  var rootProps = useGridRootProps();
+  var ownerState = {
+    align: align,
+    showRightBorder: showRightBorder,
+    isEditable: isEditable,
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  var publishMouseUp = React.useCallback(function (eventName) {
+    return function (event) {
+      var params = apiRef.current.getCellParams(rowId, field || '');
+      apiRef.current.publishEvent(eventName, params, event);
+
+      if (onMouseUp) {
+        onMouseUp(event);
+      }
+    };
+  }, [apiRef, field, onMouseUp, rowId]);
+  var publish = React.useCallback(function (eventName, propHandler) {
+    return function (event) {
+      // Ignore portal
+      if (!event.currentTarget.contains(event.target)) {
+        return;
+      } // The row might have been deleted during the click
+
+
+      if (!apiRef.current.getRow(rowId)) {
+        return;
+      }
+
+      var params = apiRef.current.getCellParams(rowId, field || '');
+      apiRef.current.publishEvent(eventName, params, event);
+
+      if (propHandler) {
+        propHandler(event);
+      }
+    };
+  }, [apiRef, field, rowId]);
+  var style = {
+    minWidth: width,
+    maxWidth: width,
+    minHeight: height,
+    maxHeight: height
+  };
+  React.useLayoutEffect(function () {
+    if (!hasFocus || cellMode === GridCellModes.Edit) {
+      return;
+    }
+
+    var doc = ownerDocument(apiRef.current.rootElementRef.current);
+
+    if (cellRef.current && !cellRef.current.contains(doc.activeElement)) {
+      var focusableElement = cellRef.current.querySelector('[tabindex="0"]');
+      var elementToFocus = focusableElement || cellRef.current;
+
+      if (doesSupportPreventScroll()) {
+        elementToFocus.focus({
+          preventScroll: true
+        });
+      } else {
+        var scrollPosition = apiRef.current.getScrollPosition();
+        elementToFocus.focus();
+        apiRef.current.scroll(scrollPosition);
+      }
+    }
+  }, [hasFocus, cellMode, apiRef]);
+  var handleFocus = other.onFocus;
+
+  if (process.env.NODE_ENV === 'test' && (_rootProps$experiment = rootProps.experimentalFeatures) != null && _rootProps$experiment.warnIfFocusStateIsNotSynced) {
+    handleFocus = function handleFocus(event) {
+      var focusedCell = gridFocusCellSelector(apiRef);
+
+      if ((focusedCell == null ? void 0 : focusedCell.id) === rowId && focusedCell.field === field) {
+        if (typeof other.onFocus === 'function') {
+          other.onFocus(event);
+        }
+
+        return;
+      }
+
+      if (!warnedOnce) {
+        console.warn(["MUI: The cell with id=".concat(rowId, " and field=").concat(field, " received focus."), "According to the state, the focus should be at id=".concat(focusedCell == null ? void 0 : focusedCell.id, ", field=").concat(focusedCell == null ? void 0 : focusedCell.field, "."), "Not syncing the state may cause unwanted behaviors since the `cellFocusIn` event won't be fired.", 'Call `fireEvent.mouseUp` before the `fireEvent.click` to sync the focus with the state.'].join('\n'));
+        warnedOnce = true;
+      }
+    };
+  }
+
+  return /*#__PURE__*/_jsx("div", _extends({
+    ref: cellRef,
+    className: clsx(className, classes.root),
+    role: "cell",
+    "data-field": field,
+    "data-colindex": colIndex,
+    "aria-colindex": colIndex + 1,
+    style: style,
+    tabIndex: cellMode === 'view' || !isEditable ? tabIndex : -1,
+    onClick: publish(GridEvents.cellClick, onClick),
+    onDoubleClick: publish(GridEvents.cellDoubleClick, onDoubleClick),
+    onMouseDown: publish(GridEvents.cellMouseDown, onMouseDown),
+    onMouseUp: publishMouseUp(GridEvents.cellMouseUp),
+    onKeyDown: publish(GridEvents.cellKeyDown, onKeyDown),
+    onDragEnter: publish(GridEvents.cellDragEnter, onDragEnter),
+    onDragOver: publish(GridEvents.cellDragOver, onDragOver)
+  }, other, {
+    onFocus: handleFocus,
+    children: children != null ? children : /*#__PURE__*/_jsx("div", {
+      className: classes.content,
+      children: valueToRender == null ? void 0 : valueToRender.toString()
+    })
+  }));
+}
+
+process.env.NODE_ENV !== "production" ? GridCell.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  align: PropTypes.oneOf(['center', 'left', 'right']).isRequired,
+  cellMode: PropTypes.oneOf(['edit', 'view']),
+  children: PropTypes.node,
+  className: PropTypes.string,
+  colIndex: PropTypes.number.isRequired,
+  field: PropTypes.string.isRequired,
+  formattedValue: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.object, PropTypes.string, PropTypes.bool]),
+  hasFocus: PropTypes.bool,
+  height: PropTypes.number.isRequired,
+  isEditable: PropTypes.bool,
+  onClick: PropTypes.func,
+  onDoubleClick: PropTypes.func,
+  onDragEnter: PropTypes.func,
+  onDragOver: PropTypes.func,
+  onKeyDown: PropTypes.func,
+  onMouseDown: PropTypes.func,
+  onMouseUp: PropTypes.func,
+  rowId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+  showRightBorder: PropTypes.bool,
+  tabIndex: PropTypes.oneOf([-1, 0]).isRequired,
+  value: PropTypes.oneOfType([PropTypes.instanceOf(Date), PropTypes.number, PropTypes.object, PropTypes.string, PropTypes.bool]),
+  width: PropTypes.number.isRequired
+} : void 0;
+export { GridCell };

package/legacy/components/cell/GridEditBooleanCell.js

@@ -0,0 +1,88 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["id", "value", "formattedValue", "api", "field", "row", "rowNode", "colDef", "cellMode", "isEditable", "tabIndex", "className", "getValue", "hasFocus", "isValidating", "isProcessingProps", "error"];
+import * as React from 'react';
+import clsx from 'clsx';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { unstable_useId as useId, unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/material/utils';
+import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes;
+  var slots = {
+    root: ['editBooleanCell']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+export function GridEditBooleanCell(props) {
+  var _rootProps$components;
+
+  var idProp = props.id,
+      value = props.value,
+      formattedValue = props.formattedValue,
+      api = props.api,
+      field = props.field,
+      row = props.row,
+      rowNode = props.rowNode,
+      colDef = props.colDef,
+      cellMode = props.cellMode,
+      isEditable = props.isEditable,
+      tabIndex = props.tabIndex,
+      className = props.className,
+      getValue = props.getValue,
+      hasFocus = props.hasFocus,
+      isValidating = props.isValidating,
+      isProcessingProps = props.isProcessingProps,
+      error = props.error,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var inputRef = React.useRef(null);
+  var id = useId();
+
+  var _React$useState = React.useState(value),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      valueState = _React$useState2[0],
+      setValueState = _React$useState2[1];
+
+  var rootProps = useGridRootProps();
+  var ownerState = {
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  var handleChange = React.useCallback(function (event) {
+    var newValue = event.target.checked;
+    setValueState(newValue);
+    api.setEditCellValue({
+      id: idProp,
+      field: field,
+      value: newValue
+    }, event);
+  }, [api, field, idProp]);
+  React.useEffect(function () {
+    setValueState(value);
+  }, [value]);
+  useEnhancedEffect(function () {
+    if (hasFocus) {
+      inputRef.current.focus();
+    }
+  }, [hasFocus]);
+  return /*#__PURE__*/_jsx("label", _extends({
+    htmlFor: id,
+    className: clsx(classes.root, className)
+  }, other, {
+    children: /*#__PURE__*/_jsx(rootProps.components.BaseCheckbox, _extends({
+      id: id,
+      inputRef: inputRef,
+      checked: Boolean(valueState),
+      onChange: handleChange,
+      size: "small"
+    }, (_rootProps$components = rootProps.componentsProps) == null ? void 0 : _rootProps$components.baseCheckbox))
+  }));
+}
+export var renderEditBooleanCell = function renderEditBooleanCell(params) {
+  return /*#__PURE__*/_jsx(GridEditBooleanCell, _extends({}, params));
+};

package/legacy/components/cell/GridEditDateCell.js

@@ -0,0 +1,150 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["id", "value", "formattedValue", "api", "field", "row", "rowNode", "colDef", "cellMode", "isEditable", "tabIndex", "hasFocus", "getValue", "inputProps", "isValidating", "isProcessingProps"];
+import * as React from 'react';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/material/utils';
+import InputBase from '@mui/material/InputBase';
+import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes;
+  var slots = {
+    root: ['editInputCell']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+export function GridEditDateCell(props) {
+  var id = props.id,
+      valueProp = props.value,
+      formattedValue = props.formattedValue,
+      api = props.api,
+      field = props.field,
+      row = props.row,
+      rowNode = props.rowNode,
+      colDef = props.colDef,
+      cellMode = props.cellMode,
+      isEditable = props.isEditable,
+      tabIndex = props.tabIndex,
+      hasFocus = props.hasFocus,
+      getValue = props.getValue,
+      inputProps = props.inputProps,
+      isValidating = props.isValidating,
+      isProcessingProps = props.isProcessingProps,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var isDateTime = colDef.type === 'dateTime';
+  var inputRef = React.useRef();
+  var valueTransformed = React.useMemo(function () {
+    var parsedDate;
+
+    if (valueProp == null) {
+      parsedDate = null;
+    } else if (valueProp instanceof Date) {
+      parsedDate = valueProp;
+    } else {
+      parsedDate = new Date((valueProp != null ? valueProp : '').toString());
+    }
+
+    var formattedDate;
+
+    if (parsedDate == null || Number.isNaN(parsedDate.getTime())) {
+      formattedDate = '';
+    } else {
+      var localDate = new Date(parsedDate.getTime() - parsedDate.getTimezoneOffset() * 60 * 1000);
+      formattedDate = localDate.toISOString().substr(0, isDateTime ? 16 : 10);
+    }
+
+    return {
+      parsed: parsedDate,
+      formatted: formattedDate
+    };
+  }, [valueProp, isDateTime]);
+
+  var _React$useState = React.useState(valueTransformed),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      valueState = _React$useState2[0],
+      setValueState = _React$useState2[1];
+
+  var rootProps = useGridRootProps();
+  var ownerState = {
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  var handleChange = React.useCallback(function (event) {
+    var newFormattedDate = event.target.value;
+    var newParsedDate;
+
+    if (newFormattedDate === '') {
+      newParsedDate = null;
+    } else {
+      var _newFormattedDate$spl = newFormattedDate.split('T'),
+          _newFormattedDate$spl2 = _slicedToArray(_newFormattedDate$spl, 2),
+          date = _newFormattedDate$spl2[0],
+          time = _newFormattedDate$spl2[1];
+
+      var _date$split = date.split('-'),
+          _date$split2 = _slicedToArray(_date$split, 3),
+          year = _date$split2[0],
+          month = _date$split2[1],
+          day = _date$split2[2];
+
+      newParsedDate = new Date();
+      newParsedDate.setFullYear(year, Number(month) - 1, day);
+      newParsedDate.setHours(0, 0, 0, 0);
+
+      if (time) {
+        var _time$split = time.split(':'),
+            _time$split2 = _slicedToArray(_time$split, 2),
+            hours = _time$split2[0],
+            minutes = _time$split2[1];
+
+        newParsedDate.setHours(Number(hours), Number(minutes), 0, 0);
+      }
+    }
+
+    setValueState({
+      parsed: newParsedDate,
+      formatted: newFormattedDate
+    });
+    api.setEditCellValue({
+      id: id,
+      field: field,
+      value: newParsedDate
+    }, event);
+  }, [api, field, id]);
+  React.useEffect(function () {
+    setValueState(function (state) {
+      var _valueTransformed$par, _state$parsed;
+
+      if (valueTransformed.parsed !== state.parsed && ((_valueTransformed$par = valueTransformed.parsed) == null ? void 0 : _valueTransformed$par.getTime()) !== ((_state$parsed = state.parsed) == null ? void 0 : _state$parsed.getTime())) {
+        return valueTransformed;
+      }
+
+      return state;
+    });
+  }, [valueTransformed]);
+  useEnhancedEffect(function () {
+    if (hasFocus) {
+      inputRef.current.focus();
+    }
+  }, [hasFocus]);
+  return /*#__PURE__*/_jsx(InputBase, _extends({
+    inputRef: inputRef,
+    fullWidth: true,
+    className: classes.root,
+    type: isDateTime ? 'datetime-local' : 'date',
+    inputProps: _extends({
+      max: isDateTime ? '9999-12-31T23:59' : '9999-12-31'
+    }, inputProps),
+    value: valueState.formatted,
+    onChange: handleChange
+  }, other));
+}
+export var renderEditDateCell = function renderEditDateCell(params) {
+  return /*#__PURE__*/_jsx(GridEditDateCell, _extends({}, params));
+};

package/legacy/components/cell/GridEditInputCell.js

@@ -0,0 +1,178 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _extends from "@babel/runtime/helpers/esm/extends";
+var _excluded = ["id", "value", "formattedValue", "api", "field", "row", "rowNode", "colDef", "cellMode", "isEditable", "tabIndex", "hasFocus", "getValue", "isValidating", "debounceMs", "isProcessingProps"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/material/utils';
+import { styled } from '@mui/material/styles';
+import InputBase from '@mui/material/InputBase';
+import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
+import { GridLoadIcon } from '../icons/index';
+import { SUBMIT_FILTER_STROKE_TIME } from '../panel/filterPanel/GridFilterInputValue';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes;
+  var slots = {
+    root: ['editInputCell']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+var GridEditInputCellRoot = styled(InputBase, {
+  name: 'MuiDataGrid',
+  slot: 'EditInputCell',
+  overridesResolver: function overridesResolver(props, styles) {
+    return styles.editInputCell;
+  }
+})(function (_ref) {
+  var theme = _ref.theme;
+  return _extends({}, theme.typography.body2, {
+    padding: '1px 0',
+    '& input': {
+      padding: '0 16px',
+      height: '100%'
+    }
+  });
+});
+
+function GridEditInputCell(props) {
+  var _rootProps$experiment;
+
+  var rootProps = useGridRootProps();
+
+  var id = props.id,
+      value = props.value,
+      formattedValue = props.formattedValue,
+      api = props.api,
+      field = props.field,
+      row = props.row,
+      rowNode = props.rowNode,
+      colDef = props.colDef,
+      cellMode = props.cellMode,
+      isEditable = props.isEditable,
+      tabIndex = props.tabIndex,
+      hasFocus = props.hasFocus,
+      getValue = props.getValue,
+      isValidating = props.isValidating,
+      _props$debounceMs = props.debounceMs,
+      debounceMs = _props$debounceMs === void 0 ? (_rootProps$experiment = rootProps.experimentalFeatures) != null && _rootProps$experiment.newEditingApi ? 200 : SUBMIT_FILTER_STROKE_TIME : _props$debounceMs,
+      isProcessingProps = props.isProcessingProps,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var inputRef = React.useRef();
+
+  var _React$useState = React.useState(value),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      valueState = _React$useState2[0],
+      setValueState = _React$useState2[1];
+
+  var ownerState = {
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  var handleChange = React.useCallback(function (event) {
+    var newValue = event.target.value;
+    setValueState(newValue);
+    api.setEditCellValue({
+      id: id,
+      field: field,
+      value: newValue,
+      debounceMs: debounceMs
+    }, event);
+  }, [api, debounceMs, field, id]);
+  React.useEffect(function () {
+    setValueState(value);
+  }, [value]);
+  useEnhancedEffect(function () {
+    if (hasFocus) {
+      inputRef.current.focus();
+    }
+  }, [hasFocus]);
+  return /*#__PURE__*/_jsx(GridEditInputCellRoot, _extends({
+    inputRef: inputRef,
+    className: classes.root,
+    fullWidth: true,
+    type: colDef.type === 'number' ? colDef.type : 'text',
+    value: valueState != null ? valueState : '',
+    onChange: handleChange,
+    endAdornment: isProcessingProps ? /*#__PURE__*/_jsx(GridLoadIcon, {}) : undefined
+  }, other));
+}
+
+process.env.NODE_ENV !== "production" ? GridEditInputCell.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+
+  /**
+   * GridApi that let you manipulate the grid.
+   * @deprecated Use the `apiRef` returned by `useGridApiContext` or `useGridApiRef` (only available in `@mui/x-data-grid-pro`)
+   */
+  api: PropTypes.any.isRequired,
+
+  /**
+   * The mode of the cell.
+   */
+  cellMode: PropTypes.oneOf(['edit', 'view']).isRequired,
+
+  /**
+   * The column of the row that the current cell belongs to.
+   */
+  colDef: PropTypes.object.isRequired,
+  debounceMs: PropTypes.number,
+
+  /**
+   * The column field of the cell that triggered the event.
+   */
+  field: PropTypes.string.isRequired,
+
+  /**
+   * The cell value formatted with the column valueFormatter.
+   */
+  formattedValue: PropTypes.any.isRequired,
+
+  /**
+   * Get the cell value of a row and field.
+   * @param {GridRowId} id The row id.
+   * @param {string} field The field.
+   * @returns {GridCellValue} The cell value.
+   * @deprecated Use `params.row` to directly access the fields you want instead.
+   */
+  getValue: PropTypes.func.isRequired,
+
+  /**
+   * If true, the cell is the active element.
+   */
+  hasFocus: PropTypes.bool.isRequired,
+
+  /**
+   * The grid row id.
+   */
+  id: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+
+  /**
+   * If true, the cell is editable.
+   */
+  isEditable: PropTypes.bool,
+  isProcessingProps: PropTypes.bool,
+  isValidating: PropTypes.bool,
+
+  /**
+   * The row model of the row that the current cell belongs to.
+   */
+  row: PropTypes.any.isRequired,
+
+  /**
+   * The node of the row that the current cell belongs to.
+   */
+  rowNode: PropTypes.object.isRequired
+} : void 0;
+export { GridEditInputCell };
+export var renderEditInputCell = function renderEditInputCell(params) {
+  return /*#__PURE__*/_jsx(GridEditInputCell, _extends({}, params));
+};