@mui/x-data-grid 6.7.0 → 6.9.0

package/hooks/features/virtualization/useGridVirtualScroller.js

@@ -1,11 +1,10 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["style"],
-  _excluded2 = ["style"],
-  _excluded3 = ["style"];
+  _excluded2 = ["style"];
 import * as React from 'react';
 import * as ReactDOM from 'react-dom';
-import { unstable_useForkRef as useForkRef, unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';
+import { unstable_useForkRef as useForkRef, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useEventCallback as useEventCallback } from '@mui/utils';
 import { useTheme } from '@mui/material/styles';
 import { defaultMemoize } from 'reselect';
 import { useGridPrivateApiContext } from '../../utils/useGridPrivateApiContext';
@@ -50,12 +49,17 @@ export const getRenderableIndexes = ({
 }) => {
   return [clamp(firstIndex - buffer, minFirstIndex, maxLastIndex), clamp(lastIndex + buffer, minFirstIndex, maxLastIndex)];
 };
-const areRenderContextsEqual = (context1, context2) => {
+export const areRenderContextsEqual = (context1, context2) => {
   if (context1 === context2) {
     return true;
   }
   return context1.firstRowIndex === context2.firstRowIndex && context1.lastRowIndex === context2.lastRowIndex && context1.firstColumnIndex === context2.firstColumnIndex && context1.lastColumnIndex === context2.lastColumnIndex;
 };
+// The `maxSize` is 3 so that reselect caches the `renderedColumns` values for the pinned left,
+// unpinned, and pinned right sections.
+const MEMOIZE_OPTIONS = {
+  maxSize: 3
+};
 export const useGridVirtualScroller = props => {
   var _currentPage$range3, _currentPage$range4;
   const apiRef = useGridPrivateApiContext();
@@ -96,7 +100,7 @@ export const useGridVirtualScroller = props => {
   const prevRootRowStyle = React.useRef();
   const getRenderedColumnsRef = React.useRef(defaultMemoize((columns, firstColumnToRender, lastColumnToRender) => {
     return columns.slice(firstColumnToRender, lastColumnToRender);
-  }));
+  }, MEMOIZE_OPTIONS));
   const getNearestIndexToRender = React.useCallback(offset => {
     var _currentPage$range, _currentPage$range2;
     const lastMeasuredIndexRelativeToAllRows = apiRef.current.getLastMeasuredRowIndex();
@@ -255,7 +259,7 @@ export const useGridVirtualScroller = props => {
     };
     apiRef.current.publishEvent('scrollPositionChange', params);
   }, [apiRef, computeRenderContext, containerDimensions.width, updateRenderContext]);
-  const handleScroll = event => {
+  const handleScroll = useEventCallback(event => {
     const {
       scrollTop,
       scrollLeft
@@ -297,13 +301,13 @@ export const useGridVirtualScroller = props => {
       });
       prevTotalWidth.current = columnsTotalWidth;
     }
-  };
-  const handleWheel = event => {
+  });
+  const handleWheel = useEventCallback(event => {
     apiRef.current.publishEvent('virtualScrollerWheel', {}, event);
-  };
-  const handleTouchMove = event => {
+  });
+  const handleTouchMove = useEventCallback(event => {
     apiRef.current.publishEvent('virtualScrollerTouchMove', {}, event);
-  };
+  });
   const getRows = (params = {
     renderContext
   }) => {
@@ -450,22 +454,25 @@ export const useGridVirtualScroller = props => {
       height,
       minHeight: shouldExtendContent ? '100%' : 'auto'
     };
+    if (rootProps.autoHeight && currentPage.rows.length === 0) {
+      size.height = getMinimalContentHeight(apiRef, rootProps.rowHeight); // Give room to show the overlay when there no rows.
+    }
+
     return size;
-  }, [rootRef, columnsTotalWidth, rowsMeta.currentPageTotalHeight, needsHorizontalScrollbar]);
+  }, [apiRef, rootRef, columnsTotalWidth, rowsMeta.currentPageTotalHeight, needsHorizontalScrollbar, rootProps.autoHeight, rootProps.rowHeight, currentPage.rows.length]);
   React.useEffect(() => {
     apiRef.current.publishEvent('virtualScrollerContentSizeChange');
   }, [apiRef, contentSize]);
-  if (rootProps.autoHeight && currentPage.rows.length === 0) {
-    contentSize.height = getMinimalContentHeight(apiRef, rootProps.rowHeight); // Give room to show the overlay when there no rows.
-  }
-
-  const rootStyle = {};
-  if (!needsHorizontalScrollbar) {
-    rootStyle.overflowX = 'hidden';
-  }
-  if (rootProps.autoHeight) {
-    rootStyle.overflowY = 'hidden';
-  }
+  const rootStyle = React.useMemo(() => {
+    const style = {};
+    if (!needsHorizontalScrollbar) {
+      style.overflowX = 'hidden';
+    }
+    if (rootProps.autoHeight) {
+      style.overflowY = 'hidden';
+    }
+    return style;
+  }, [needsHorizontalScrollbar, rootProps.autoHeight]);
   const getRenderContext = React.useCallback(() => {
     return prevRenderContext.current;
   }, []);
@@ -476,23 +483,18 @@ export const useGridVirtualScroller = props => {
     renderContext,
     updateRenderZonePosition,
     getRows,
-    getRootProps: (_ref3 = {}) => {
-      let {
-          style = {}
-        } = _ref3,
-        other = _objectWithoutPropertiesLoose(_ref3, _excluded3);
-      return _extends({
-        ref: handleRef,
-        onScroll: handleScroll,
-        onWheel: handleWheel,
-        onTouchMove: handleTouchMove,
-        style: _extends({}, style, rootStyle)
-      }, other);
-    },
+    getRootProps: (inputProps = {}) => _extends({
+      ref: handleRef,
+      onScroll: handleScroll,
+      onWheel: handleWheel,
+      onTouchMove: handleTouchMove
+    }, inputProps, {
+      style: inputProps.style ? _extends({}, inputProps.style, rootStyle) : rootStyle
+    }),
     getContentProps: ({
-      style = {}
+      style
     } = {}) => ({
-      style: _extends({}, style, contentSize)
+      style: style ? _extends({}, style, contentSize) : contentSize
     }),
     getRenderZoneProps: () => ({
       ref: renderZoneRef

package/hooks/utils/index.d.ts

@@ -1,6 +1,6 @@
 export * from './useGridApiEventHandler';
 export * from './useGridApiMethod';
 export * from './useGridLogger';
-export * from './useGridSelector';
+export { useGridSelector } from './useGridSelector';
 export * from './useGridNativeEventListener';
 export * from './useFirstRender';

package/hooks/utils/index.js

@@ -1,6 +1,6 @@
 export * from './useGridApiEventHandler';
 export * from './useGridApiMethod';
 export * from './useGridLogger';
-export * from './useGridSelector';
+export { useGridSelector } from './useGridSelector';
 export * from './useGridNativeEventListener';
 export * from './useFirstRender';

package/hooks/utils/useGridSelector.d.ts

@@ -1,4 +1,6 @@
 import * as React from 'react';
 import { GridApiCommon } from '../../models/api/gridApiCommon';
 import { OutputSelector } from '../../utils/createSelector';
-export declare const useGridSelector: <Api extends GridApiCommon<any, any>, T>(apiRef: React.MutableRefObject<Api>, selector: OutputSelector<Api["state"], T> | ((state: Api["state"]) => T)) => T;
+import { fastObjectShallowCompare } from '../../utils/fastObjectShallowCompare';
+export declare const objectShallowCompare: typeof fastObjectShallowCompare;
+export declare const useGridSelector: <Api extends GridApiCommon<any, any>, T>(apiRef: React.MutableRefObject<Api>, selector: OutputSelector<Api["state"], T> | ((state: Api["state"]) => T), equals?: (a: T, b: T) => boolean) => T;

package/hooks/utils/useGridSelector.js

@@ -1,16 +1,47 @@
+import * as React from 'react';
+import { useLazyRef } from './useLazyRef';
+import { useOnMount } from './useOnMount';
 import { buildWarning } from '../../utils/warning';
+import { fastObjectShallowCompare } from '../../utils/fastObjectShallowCompare';
+const stateNotInitializedWarning = buildWarning(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.']);
 function isOutputSelector(selector) {
   return selector.acceptsApiRef;
 }
-const stateNotInitializedWarning = buildWarning(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.']);
-export const useGridSelector = (apiRef, selector) => {
+function applySelector(apiRef, selector) {
+  if (isOutputSelector(selector)) {
+    return selector(apiRef);
+  }
+  return selector(apiRef.current.state);
+}
+const defaultCompare = Object.is;
+export const objectShallowCompare = fastObjectShallowCompare;
+const createRefs = () => ({
+  state: null,
+  equals: null,
+  selector: null
+});
+export const useGridSelector = (apiRef, selector, equals = defaultCompare) => {
   if (process.env.NODE_ENV !== 'production') {
     if (!apiRef.current.state) {
       stateNotInitializedWarning();
     }
   }
-  if (isOutputSelector(selector)) {
-    return selector(apiRef);
-  }
-  return selector(apiRef.current.state);
+  const refs = useLazyRef(createRefs);
+  const didInit = refs.current.selector !== null;
+  const [state, setState] = React.useState(
+  // We don't use an initialization function to avoid allocations
+  didInit ? null : applySelector(apiRef, selector));
+  refs.current.state = state;
+  refs.current.equals = equals;
+  refs.current.selector = selector;
+  useOnMount(() => {
+    return apiRef.current.store.subscribe(() => {
+      const newState = applySelector(apiRef, refs.current.selector);
+      if (!refs.current.equals(refs.current.state, newState)) {
+        refs.current.state = newState;
+        setState(newState);
+      }
+    });
+  });
+  return state;
 };

package/hooks/utils/useLazyRef.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare function useLazyRef<T, U>(init: (arg?: U) => T, initArg?: U): React.MutableRefObject<T>;

package/hooks/utils/useLazyRef.js

@@ -0,0 +1,9 @@
+import * as React from 'react';
+const UNINITIALIZED = {};
+export function useLazyRef(init, initArg) {
+  const ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = init(initArg);
+  }
+  return ref;
+}

package/hooks/utils/useOnMount.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare function useOnMount(fn: React.EffectCallback): void;

package/hooks/utils/useOnMount.js

@@ -0,0 +1,7 @@
+import * as React from 'react';
+const EMPTY = [];
+export function useOnMount(fn) {
+  /* eslint-disable react-hooks/exhaustive-deps */
+  React.useEffect(fn, EMPTY);
+  /* eslint-enable react-hooks/exhaustive-deps */
+}

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid v6.7.0
+ * @mui/x-data-grid v6.9.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/index.d.ts

@@ -61,7 +61,7 @@ export { useGridInitializeState } from '../hooks/utils/useGridInitializeState';
 export type { GridStateInitializer } from '../hooks/utils/useGridInitializeState';
 export type { GridExperimentalFeatures, DataGridPropsWithoutDefaultValue, DataGridPropsWithDefaultValues, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPropsWithComplexDefaultValueBeforeProcessing, } from '../models/props/DataGridProps';
 export { getColumnsToExport, defaultGetRowsToExport } from '../hooks/features/export/utils';
-export { createSelector, unstable_resetCreateSelectorCache } from '../utils/createSelector';
+export { createSelector, createSelectorMemoized, unstable_resetCreateSelectorCache, } from '../utils/createSelector';
 export { findParentElementFromClassName, getActiveElement } from '../utils/domUtils';
 export { isNavigationKey } from '../utils/keyboardUtils';
 export { clamp, isDeepEqual, isNumber, isFunction, isObject } from '../utils/utils';

package/internals/index.js

@@ -48,7 +48,7 @@ export { useGridVirtualScroller, getRenderableIndexes } from '../hooks/features/
 export { useGridVisibleRows, getVisibleRows } from '../hooks/utils/useGridVisibleRows';
 export { useGridInitializeState } from '../hooks/utils/useGridInitializeState';
 export { getColumnsToExport, defaultGetRowsToExport } from '../hooks/features/export/utils';
-export { createSelector, unstable_resetCreateSelectorCache } from '../utils/createSelector';
+export { createSelector, createSelectorMemoized, unstable_resetCreateSelectorCache } from '../utils/createSelector';
 export { findParentElementFromClassName, getActiveElement } from '../utils/domUtils';
 export { isNavigationKey } from '../utils/keyboardUtils';
 export { clamp, isDeepEqual, isNumber, isFunction, isObject } from '../utils/utils';

package/legacy/components/GridColumnHeaders.js

@@ -3,6 +3,7 @@ import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutPr
 var _excluded = ["innerRef", "className", "visibleColumns", "sortColumnLookup", "filterColumnLookup", "columnPositions", "columnHeaderTabIndexState", "columnGroupHeaderTabIndexState", "columnHeaderFocus", "columnGroupHeaderFocus", "densityFactor", "headerGroupingMaxDepth", "columnMenuState", "columnVisibility", "columnGroupsHeaderStructure", "hasOtherElementInTabSequence"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
+import { fastMemo } from '../utils/fastMemo';
 import { useGridColumnHeaders } from '../hooks/features/columnHeaders/useGridColumnHeaders';
 import { GridBaseColumnHeaders } from './columnHeaders/GridBaseColumnHeaders';
 import { GridColumnHeadersInner } from './columnHeaders/GridColumnHeadersInner';
@@ -98,4 +99,5 @@ process.env.NODE_ENV !== "production" ? GridColumnHeaders.propTypes = {
   sortColumnLookup: PropTypes.object.isRequired,
   visibleColumns: PropTypes.arrayOf(PropTypes.object).isRequired
 } : void 0;
-export { GridColumnHeaders };
+var MemoizedGridColumnHeaders = fastMemo(GridColumnHeaders);
+export { MemoizedGridColumnHeaders as GridColumnHeaders };

package/legacy/components/GridRow.js

@@ -2,18 +2,18 @@ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 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 = ["selected", "rowId", "row", "index", "style", "position", "rowHeight", "className", "visibleColumns", "renderedColumns", "containerWidth", "firstColumnToRender", "lastColumnToRender", "isLastVisible", "focusedCell", "tabbableCell", "onClick", "onDoubleClick", "onMouseEnter", "onMouseLeave"],
-  _excluded2 = ["changeReason", "unstable_updateValueOnRender"];
+var _excluded = ["selected", "rowId", "row", "index", "style", "position", "rowHeight", "className", "visibleColumns", "renderedColumns", "containerWidth", "firstColumnToRender", "lastColumnToRender", "isLastVisible", "focusedCell", "tabbableCell", "onClick", "onDoubleClick", "onMouseEnter", "onMouseLeave"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import { unstable_composeClasses as composeClasses, unstable_useForkRef as useForkRef } from '@mui/utils';
+import { fastMemo } from '../utils/fastMemo';
 import { GridEditModes, GridRowModes, GridCellModes } from '../models/gridEditRowModel';
 import { useGridApiContext } from '../hooks/utils/useGridApiContext';
 import { getDataGridUtilityClass, gridClasses } from '../constants/gridClasses';
 import { useGridRootProps } from '../hooks/utils/useGridRootProps';
 import { gridColumnsTotalWidthSelector } from '../hooks/features/columns/gridColumnsSelector';
-import { useGridSelector } from '../hooks/utils/useGridSelector';
+import { useGridSelector, objectShallowCompare } from '../hooks/utils/useGridSelector';
 import { useGridVisibleRows } from '../hooks/utils/useGridVisibleRows';
 import { findParentElementFromClassName } from '../utils/domUtils';
 import { GRID_CHECKBOX_SELECTION_COL_DEF } from '../colDef/gridCheckboxSelectionColDef';
@@ -23,6 +23,7 @@ import { gridSortModelSelector } from '../hooks/features/sorting/gridSortingSele
 import { gridRowMaximumTreeDepthSelector } from '../hooks/features/rows/gridRowsSelector';
 import { gridColumnGroupsHeaderMaxDepthSelector } from '../hooks/features/columnGrouping/gridColumnGroupsSelector';
 import { randomNumberBetween } from '../utils/utils';
+import { GridCellWrapper, GridCellV7 } from './cell/GridCell';
 import { gridEditRowsStateSelector } from '../hooks/features/editing/gridEditingSelectors';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
@@ -187,79 +188,29 @@ var GridRow = /*#__PURE__*/React.forwardRef(function GridRow(props, refProp) {
   }, [apiRef, onClick, publish, rowId]);
   var slots = rootProps.slots,
     slotProps = rootProps.slotProps,
-    rootClasses = rootProps.classes,
-    disableColumnReorder = rootProps.disableColumnReorder,
-    getCellClassName = rootProps.getCellClassName;
+    disableColumnReorder = rootProps.disableColumnReorder;
+  var CellComponent = slots.cell === GridCellV7 ? GridCellV7 : GridCellWrapper;
   var rowReordering = rootProps.rowReordering;
-  var CellComponent = slots.cell;
-  var getCell = React.useCallback(function (column, cellProps) {
-    var cellParams = apiRef.current.getCellParams(rowId, column.field);
-    var classNames = apiRef.current.unstable_applyPipeProcessors('cellClassName', [], {
-      id: rowId,
-      field: column.field
-    });
+  var getCell = function getCell(column, cellProps) {
+    var _editRowsState$rowId$, _editRowsState$rowId;
     var disableDragEvents = disableColumnReorder && column.disableReorder || !rowReordering && !!sortModel.length && treeDepth > 1 && Object.keys(editRowsState).length > 0;
-    if (column.cellClassName) {
-      classNames.push(clsx(typeof column.cellClassName === 'function' ? column.cellClassName(cellParams) : column.cellClassName));
-    }
-    var editCellState = editRowsState[rowId] ? editRowsState[rowId][column.field] : null;
-    var content;
-    if (editCellState == null && column.renderCell) {
-      content = column.renderCell(_extends({}, cellParams, {
-        api: apiRef.current
-      }));
-      // TODO move to GridCell
-      classNames.push(clsx(gridClasses['cell--withRenderer'], rootClasses == null ? void 0 : rootClasses['cell--withRenderer']));
-    }
-    if (editCellState != null && column.renderEditCell) {
-      var updatedRow = apiRef.current.getRowWithUpdatedValues(rowId, column.field);
-
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      var changeReason = editCellState.changeReason,
-        unstable_updateValueOnRender = editCellState.unstable_updateValueOnRender,
-        editCellStateRest = _objectWithoutProperties(editCellState, _excluded2);
-      var params = _extends({}, cellParams, {
-        row: updatedRow
-      }, editCellStateRest, {
-        api: apiRef.current
-      });
-      content = column.renderEditCell(params);
-      // TODO move to GridCell
-      classNames.push(clsx(gridClasses['cell--editing'], rootClasses == null ? void 0 : rootClasses['cell--editing']));
-    }
-    if (getCellClassName) {
-      // TODO move to GridCell
-      classNames.push(getCellClassName(cellParams));
-    }
-    var hasFocus = focusedCell === column.field;
-    var tabIndex = tabbableCell === column.field ? 0 : -1;
-    var isSelected = apiRef.current.unstable_applyPipeProcessors('isCellSelected', false, {
-      id: rowId,
-      field: column.field
-    });
+    var editCellState = (_editRowsState$rowId$ = (_editRowsState$rowId = editRowsState[rowId]) == null ? void 0 : _editRowsState$rowId[column.field]) != null ? _editRowsState$rowId$ : null;
     return /*#__PURE__*/_jsx(CellComponent, _extends({
-      value: cellParams.value,
-      field: column.field,
+      column: column,
       width: cellProps.width,
       rowId: rowId,
       height: rowHeight,
       showRightBorder: cellProps.showRightBorder,
-      formattedValue: cellParams.formattedValue,
       align: column.align || 'left',
-      cellMode: cellParams.cellMode,
       colIndex: cellProps.indexRelativeToAllColumns,
-      isEditable: cellParams.isEditable,
-      isSelected: isSelected,
-      hasFocus: hasFocus,
-      tabIndex: tabIndex,
-      className: clsx(classNames),
       colSpan: cellProps.colSpan,
-      disableDragEvents: disableDragEvents
-    }, slotProps == null ? void 0 : slotProps.cell, {
-      children: content
-    }), column.field);
-  }, [apiRef, rowId, disableColumnReorder, rowReordering, sortModel.length, treeDepth, editRowsState, getCellClassName, focusedCell, tabbableCell, CellComponent, rowHeight, slotProps == null ? void 0 : slotProps.cell, rootClasses]);
-  var sizes = apiRef.current.unstable_getRowInternalSizes(rowId);
+      disableDragEvents: disableDragEvents,
+      editCellState: editCellState
+    }, slotProps == null ? void 0 : slotProps.cell), column.field);
+  };
+  var sizes = useGridSelector(apiRef, function () {
+    return _extends({}, apiRef.current.unstable_getRowInternalSizes(rowId));
+  }, objectShallowCompare);
   var minHeight = rowHeight;
   if (minHeight === 'auto' && sizes) {
     var numberOfBaseSizes = 0;
@@ -312,7 +263,11 @@ var GridRow = /*#__PURE__*/React.forwardRef(function GridRow(props, refProp) {
     rowClassNames.push(rootProps.getRowClassName(rowParams));
   }
   var randomNumber = randomNumberBetween(10000, 20, 80);
-  var rowType = apiRef.current.getRowNode(rowId).type;
+  var rowNode = apiRef.current.getRowNode(rowId);
+  if (!rowNode) {
+    return null;
+  }
+  var rowType = rowNode.type;
   var cells = [];
   for (var i = 0; i < renderedColumns.length; i += 1) {
     var column = renderedColumns[i];
@@ -333,7 +288,7 @@ var GridRow = /*#__PURE__*/React.forwardRef(function GridRow(props, refProp) {
       } else {
         var _width = cellColSpanInfo.cellProps.width;
         var contentWidth = Math.round(randomNumber());
-        cells.push( /*#__PURE__*/_jsx(rootProps.slots.skeletonCell, {
+        cells.push( /*#__PURE__*/_jsx(slots.skeletonCell, {
           width: _width,
           contentWidth: contentWidth,
           field: column.field,
@@ -369,8 +324,8 @@ process.env.NODE_ENV !== "production" ? GridRow.propTypes = {
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "yarn proptypes"  |
   // ----------------------------------------------------------------------
-  containerWidth: PropTypes.number,
-  firstColumnToRender: PropTypes.number,
+  containerWidth: PropTypes.number.isRequired,
+  firstColumnToRender: PropTypes.number.isRequired,
   /**
    * Determines which cell has focus.
    * If `null`, no cell in this row has focus.
@@ -380,24 +335,25 @@ process.env.NODE_ENV !== "production" ? GridRow.propTypes = {
    * Index of the row in the whole sorted and filtered dataset.
    * If some rows above have expanded children, this index also take those children into account.
    */
-  index: PropTypes.number,
+  index: PropTypes.number.isRequired,
   isLastVisible: PropTypes.bool,
-  lastColumnToRender: PropTypes.number,
+  lastColumnToRender: PropTypes.number.isRequired,
   onClick: PropTypes.func,
   onDoubleClick: PropTypes.func,
   onMouseEnter: PropTypes.func,
   onMouseLeave: PropTypes.func,
-  position: PropTypes.oneOf(['center', 'left', 'right']),
-  renderedColumns: PropTypes.arrayOf(PropTypes.object),
+  position: PropTypes.oneOf(['center', 'left', 'right']).isRequired,
+  renderedColumns: PropTypes.arrayOf(PropTypes.object).isRequired,
   row: PropTypes.object,
-  rowHeight: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
-  rowId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
-  selected: PropTypes.bool,
+  rowHeight: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]).isRequired,
+  rowId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
+  selected: PropTypes.bool.isRequired,
   /**
    * Determines which cell should be tabbable by having tabIndex=0.
    * If `null`, no cell in this row is in the tab sequence.
    */
   tabbableCell: PropTypes.string,
-  visibleColumns: PropTypes.arrayOf(PropTypes.object)
+  visibleColumns: PropTypes.arrayOf(PropTypes.object).isRequired
 } : void 0;
-export { GridRow };
+var MemoizedGridRow = fastMemo(GridRow);
+export { MemoizedGridRow as GridRow };