@elastic/eui 76.1.0 → 76.2.0

package/optimize/es/components/datagrid/body/data_grid_body_virtualized.js

@@ -0,0 +1,311 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _excluded = ["children", "style"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+import classNames from 'classnames';
+import React, { forwardRef, createContext, useContext, useEffect, useRef } from 'react';
+import { VariableSizeGrid as Grid } from 'react-window';
+import { useResizeObserver } from '../../observer/resize_observer';
+import { useDataGridHeader } from './header';
+import { useDataGridFooter } from './footer';
+import { Cell } from './data_grid_cell_wrapper';
+import { useRowManager } from './data_grid_row_manager';
+import { useFinalGridDimensions, useUnconstrainedHeight, useVirtualizeContainerWidth } from '../utils/grid_height_width';
+import { useDefaultColumnWidth, useColumnWidths } from '../utils/col_widths';
+import { useRowHeightUtils, useDefaultRowHeight } from '../utils/row_heights';
+import { useScrollBars, useScroll } from '../utils/scrolling';
+import { IS_JEST_ENVIRONMENT } from '../../../utils';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+export var _Cell = function _Cell(_ref) {
+  var columnIndex = _ref.columnIndex,
+      rowIndex = _ref.rowIndex,
+      style = _ref.style,
+      data = _ref.data;
+
+  var _useContext = useContext(DataGridWrapperRowsContext),
+      headerRowHeight = _useContext.headerRowHeight;
+
+  return ___EmotionJSX(Cell, _extends({
+    colIndex: columnIndex,
+    visibleRowIndex: rowIndex,
+    style: _objectSpread(_objectSpread({}, style), {}, {
+      top: "".concat(parseFloat(style.top) + headerRowHeight, "px")
+    })
+  }, data));
+}; // Context is required to pass props to react-window's innerElementType
+// @see https://github.com/bvaughn/react-window/issues/404
+
+export var DataGridWrapperRowsContext = /*#__PURE__*/createContext({
+  headerRow: ___EmotionJSX("div", null),
+  headerRowHeight: 0,
+  footerRow: null
+});
+var InnerElement = /*#__PURE__*/forwardRef(function (_ref2, ref) {
+  var children = _ref2.children,
+      style = _ref2.style,
+      rest = _objectWithoutProperties(_ref2, _excluded);
+
+  var _useContext2 = useContext(DataGridWrapperRowsContext),
+      headerRowHeight = _useContext2.headerRowHeight,
+      headerRow = _useContext2.headerRow,
+      footerRow = _useContext2.footerRow;
+
+  return ___EmotionJSX(React.Fragment, null, ___EmotionJSX("div", _extends({
+    ref: ref,
+    style: _objectSpread(_objectSpread({}, style), {}, {
+      height: style.height + headerRowHeight
+    })
+  }, rest), headerRow, children), footerRow);
+});
+InnerElement.displayName = 'EuiDataGridInnerElement';
+export var EuiDataGridBodyVirtualized = function EuiDataGridBodyVirtualized(_ref3) {
+  var leadingControlColumns = _ref3.leadingControlColumns,
+      trailingControlColumns = _ref3.trailingControlColumns,
+      columns = _ref3.columns,
+      visibleColCount = _ref3.visibleColCount,
+      schema = _ref3.schema,
+      schemaDetectors = _ref3.schemaDetectors,
+      rowCount = _ref3.rowCount,
+      _ref3$visibleRows = _ref3.visibleRows,
+      startRow = _ref3$visibleRows.startRow,
+      endRow = _ref3$visibleRows.endRow,
+      visibleRowCount = _ref3$visibleRows.visibleRowCount,
+      renderCellValue = _ref3.renderCellValue,
+      renderCellPopover = _ref3.renderCellPopover,
+      renderFooterCellValue = _ref3.renderFooterCellValue,
+      interactiveCellId = _ref3.interactiveCellId,
+      pagination = _ref3.pagination,
+      headerIsInteractive = _ref3.headerIsInteractive,
+      handleHeaderMutation = _ref3.handleHeaderMutation,
+      setVisibleColumns = _ref3.setVisibleColumns,
+      switchColumnPos = _ref3.switchColumnPos,
+      onColumnResize = _ref3.onColumnResize,
+      rowHeightsOptions = _ref3.rowHeightsOptions,
+      virtualizationOptions = _ref3.virtualizationOptions,
+      isFullScreen = _ref3.isFullScreen,
+      gridStyles = _ref3.gridStyles,
+      gridWidth = _ref3.gridWidth,
+      gridRef = _ref3.gridRef,
+      gridItemsRendered = _ref3.gridItemsRendered,
+      wrapperRef = _ref3.wrapperRef;
+
+  /**
+   * Grid refs & observers
+   */
+  var wrapperDimensions = useResizeObserver(wrapperRef.current);
+  var outerGridRef = useRef(null); // container that becomes scrollable
+
+  var innerGridRef = useRef(null); // container sized to fit all content
+
+  /**
+   * Scroll bars
+   */
+
+  var _useScrollBars = useScrollBars(outerGridRef, gridStyles.border),
+      scrollBarHeight = _useScrollBars.scrollBarHeight,
+      hasVerticalScroll = _useScrollBars.hasVerticalScroll,
+      hasHorizontalScroll = _useScrollBars.hasHorizontalScroll,
+      scrollBorderOverlay = _useScrollBars.scrollBorderOverlay;
+  /**
+   * Widths
+   */
+
+
+  var virtualizeContainerWidth = useVirtualizeContainerWidth(outerGridRef.current, gridWidth, pagination === null || pagination === void 0 ? void 0 : pagination.pageSize); // compute the default column width from the container's width and count of visible columns
+
+  var defaultColumnWidth = useDefaultColumnWidth(virtualizeContainerWidth, leadingControlColumns, trailingControlColumns, columns);
+
+  var _useColumnWidths = useColumnWidths({
+    columns: columns,
+    leadingControlColumns: leadingControlColumns,
+    trailingControlColumns: trailingControlColumns,
+    defaultColumnWidth: defaultColumnWidth,
+    onColumnResize: onColumnResize
+  }),
+      columnWidths = _useColumnWidths.columnWidths,
+      setColumnWidth = _useColumnWidths.setColumnWidth,
+      getColumnWidth = _useColumnWidths.getColumnWidth;
+  /**
+   * Header & footer
+   */
+
+
+  var _useDataGridHeader = useDataGridHeader({
+    headerIsInteractive: headerIsInteractive,
+    handleHeaderMutation: handleHeaderMutation,
+    switchColumnPos: switchColumnPos,
+    setVisibleColumns: setVisibleColumns,
+    leadingControlColumns: leadingControlColumns,
+    trailingControlColumns: trailingControlColumns,
+    columns: columns,
+    columnWidths: columnWidths,
+    defaultColumnWidth: defaultColumnWidth,
+    setColumnWidth: setColumnWidth,
+    schema: schema,
+    schemaDetectors: schemaDetectors
+  }),
+      headerRow = _useDataGridHeader.headerRow,
+      headerRowHeight = _useDataGridHeader.headerRowHeight;
+
+  var _useDataGridFooter = useDataGridFooter({
+    renderFooterCellValue: renderFooterCellValue,
+    renderCellPopover: renderCellPopover,
+    rowIndex: visibleRowCount,
+    visibleRowIndex: visibleRowCount,
+    interactiveCellId: interactiveCellId,
+    leadingControlColumns: leadingControlColumns,
+    trailingControlColumns: trailingControlColumns,
+    columns: columns,
+    columnWidths: columnWidths,
+    defaultColumnWidth: defaultColumnWidth,
+    schema: schema
+  }),
+      footerRow = _useDataGridFooter.footerRow,
+      footerRowHeight = _useDataGridFooter.footerRowHeight;
+  /**
+   * Handle scrolling cells fully into view
+   */
+
+
+  useScroll({
+    gridRef: gridRef,
+    outerGridRef: outerGridRef,
+    hasGridScrolling: hasVerticalScroll || hasHorizontalScroll,
+    headerRowHeight: headerRowHeight,
+    footerRowHeight: footerRowHeight,
+    visibleRowCount: visibleRowCount,
+    hasStickyFooter: !!(renderFooterCellValue && gridStyles.stickyFooter)
+  });
+  /**
+   * Row manager
+   */
+
+  var rowManager = useRowManager({
+    innerGridRef: innerGridRef,
+    rowClasses: gridStyles.rowClasses
+  });
+  /**
+   * Heights
+   */
+
+  var rowHeightUtils = useRowHeightUtils({
+    virtualization: {
+      gridRef: gridRef,
+      outerGridElementRef: outerGridRef,
+      gridItemsRenderedRef: gridItemsRendered
+    },
+    rowHeightsOptions: rowHeightsOptions,
+    gridStyles: gridStyles,
+    columns: columns
+  });
+
+  var _useDefaultRowHeight = useDefaultRowHeight({
+    rowHeightsOptions: rowHeightsOptions,
+    rowHeightUtils: rowHeightUtils
+  }),
+      defaultRowHeight = _useDefaultRowHeight.defaultRowHeight,
+      setRowHeight = _useDefaultRowHeight.setRowHeight,
+      getRowHeight = _useDefaultRowHeight.getRowHeight;
+
+  var unconstrainedHeight = useUnconstrainedHeight({
+    rowHeightUtils: rowHeightUtils,
+    startRow: startRow,
+    endRow: endRow,
+    rowHeightsOptions: rowHeightsOptions,
+    defaultRowHeight: defaultRowHeight,
+    headerRowHeight: headerRowHeight,
+    footerRowHeight: footerRowHeight,
+    scrollBarHeight: scrollBarHeight,
+    innerGridRef: innerGridRef
+  });
+  /**
+   * Final grid height & width
+   */
+
+  var _useFinalGridDimensio = useFinalGridDimensions({
+    unconstrainedHeight: unconstrainedHeight,
+    unconstrainedWidth: 0,
+    // unable to determine this until the container's size is known
+    wrapperDimensions: wrapperDimensions,
+    wrapperRef: wrapperRef,
+    isFullScreen: isFullScreen,
+    rowCount: rowCount
+  }),
+      finalWidth = _useFinalGridDimensio.finalWidth,
+      finalHeight = _useFinalGridDimensio.finalHeight;
+  /**
+   * Grid resets
+   */
+
+
+  useEffect(function () {
+    if (gridRef.current) {
+      gridRef.current.resetAfterColumnIndex(0);
+    }
+  }, [gridRef, columns, columnWidths, defaultColumnWidth]);
+  useEffect(function () {
+    if (gridRef.current && rowHeightsOptions) {
+      gridRef.current.resetAfterRowIndex(0);
+    }
+  }, [gridRef, pagination === null || pagination === void 0 ? void 0 : pagination.pageIndex, rowHeightsOptions, gridStyles === null || gridStyles === void 0 ? void 0 : gridStyles.cellPadding, gridStyles === null || gridStyles === void 0 ? void 0 : gridStyles.fontSize]);
+  useEffect(function () {
+    if (gridRef.current) {
+      gridRef.current.resetAfterRowIndex(0);
+    }
+  }, [gridRef, getRowHeight]);
+  return IS_JEST_ENVIRONMENT || finalWidth > 0 ? ___EmotionJSX(DataGridWrapperRowsContext.Provider, {
+    value: {
+      headerRowHeight: headerRowHeight,
+      headerRow: headerRow,
+      footerRow: footerRow
+    }
+  }, ___EmotionJSX(Grid, _extends({}, virtualizationOptions ? virtualizationOptions : {}, {
+    ref: gridRef,
+    className: classNames('euiDataGrid__virtualized', virtualizationOptions === null || virtualizationOptions === void 0 ? void 0 : virtualizationOptions.className),
+    onItemsRendered: function onItemsRendered(itemsRendered) {
+      var _virtualizationOption;
+
+      gridItemsRendered.current = itemsRendered;
+      virtualizationOptions === null || virtualizationOptions === void 0 ? void 0 : (_virtualizationOption = virtualizationOptions.onItemsRendered) === null || _virtualizationOption === void 0 ? void 0 : _virtualizationOption.call(virtualizationOptions, itemsRendered);
+    },
+    innerElementType: InnerElement,
+    outerRef: outerGridRef,
+    innerRef: innerGridRef,
+    columnCount: visibleColCount,
+    width: finalWidth,
+    columnWidth: getColumnWidth,
+    height: finalHeight,
+    rowHeight: getRowHeight,
+    itemData: {
+      schemaDetectors: schemaDetectors,
+      setRowHeight: setRowHeight,
+      leadingControlColumns: leadingControlColumns,
+      trailingControlColumns: trailingControlColumns,
+      columns: columns,
+      visibleColCount: visibleColCount,
+      schema: schema,
+      columnWidths: columnWidths,
+      defaultColumnWidth: defaultColumnWidth,
+      renderCellValue: renderCellValue,
+      renderCellPopover: renderCellPopover,
+      interactiveCellId: interactiveCellId,
+      rowHeightsOptions: rowHeightsOptions,
+      rowHeightUtils: rowHeightUtils,
+      rowManager: rowManager,
+      pagination: pagination
+    },
+    rowCount: IS_JEST_ENVIRONMENT || headerRowHeight > 0 ? visibleRowCount : 0
+  }), _Cell), scrollBorderOverlay) : null;
+};

package/optimize/es/components/datagrid/body/data_grid_cell.js

@@ -410,7 +410,7 @@ export var EuiDataGridCell = /*#__PURE__*/function (_Component) {
   }, {
     key: "componentDidUpdate",
     value: function componentDidUpdate(prevProps) {
-      var _this$props$rowHeight, _prevProps$rowHeights, _this$props$rowHeight2, _this$props$style, _prevProps$style;
+      var _this$props$rowHeight, _prevProps$rowHeights, _this$props$rowHeight2, _this$props$rowHeight3, _this$props$style, _prevProps$style;
 
       this.recalculateAutoHeight();
 
@@ -418,16 +418,17 @@ export var EuiDataGridCell = /*#__PURE__*/function (_Component) {
         this.recalculateLineHeight();
       }
 
-      if ((_this$props$rowHeight2 = this.props.rowHeightsOptions) !== null && _this$props$rowHeight2 !== void 0 && _this$props$rowHeight2.scrollAnchorRow && this.props.colIndex === 0 && // once per row
+      if ((_this$props$rowHeight2 = this.props.rowHeightUtils) !== null && _this$props$rowHeight2 !== void 0 && _this$props$rowHeight2.compensateForLayoutShift && (_this$props$rowHeight3 = this.props.rowHeightsOptions) !== null && _this$props$rowHeight3 !== void 0 && _this$props$rowHeight3.scrollAnchorRow && this.props.colIndex === 0 && // once per row
       this.props.columnId === prevProps.columnId && // if this is still the same column
       this.props.rowIndex === prevProps.rowIndex && // if this is still the same row
       ((_this$props$style = this.props.style) === null || _this$props$style === void 0 ? void 0 : _this$props$style.top) !== ((_prevProps$style = prevProps.style) === null || _prevProps$style === void 0 ? void 0 : _prevProps$style.top) // if the top position has changed
       ) {
-        var _prevProps$style2, _this$props$style2, _this$props$rowHeight3, _this$props$rowHeight4;
+        var _prevProps$style2, _this$props$style2, _this$props$rowHeight4;
 
         var previousTop = parseFloat((_prevProps$style2 = prevProps.style) === null || _prevProps$style2 === void 0 ? void 0 : _prevProps$style2.top);
-        var currentTop = parseFloat((_this$props$style2 = this.props.style) === null || _this$props$style2 === void 0 ? void 0 : _this$props$style2.top);
-        (_this$props$rowHeight3 = this.props.rowHeightUtils) === null || _this$props$rowHeight3 === void 0 ? void 0 : _this$props$rowHeight3.compensateForLayoutShift(this.props.rowIndex, currentTop - previousTop, (_this$props$rowHeight4 = this.props.rowHeightsOptions) === null || _this$props$rowHeight4 === void 0 ? void 0 : _this$props$rowHeight4.scrollAnchorRow);
+        var currentTop = parseFloat((_this$props$style2 = this.props.style) === null || _this$props$style2 === void 0 ? void 0 : _this$props$style2.top); // @ts-ignore We've already checked that this virtualization util is available above
+
+        this.props.rowHeightUtils.compensateForLayoutShift(this.props.rowIndex, currentTop - previousTop, (_this$props$rowHeight4 = this.props.rowHeightsOptions) === null || _this$props$rowHeight4 === void 0 ? void 0 : _this$props$rowHeight4.scrollAnchorRow);
       }
 
       if (this.props.popoverContext.popoverIsOpen !== prevProps.popoverContext.popoverIsOpen || this.props.popoverContext.cellLocation !== prevProps.popoverContext.cellLocation || this.props.renderCellPopover !== prevProps.renderCellPopover) {
@@ -517,8 +518,8 @@ export var EuiDataGridCell = /*#__PURE__*/function (_Component) {
       });
 
       cellProps.style = _objectSpread(_objectSpread({}, style), {}, {
-        // from react-window
-        top: 0,
+        // set by react-window or the custom renderer
+        top: style !== null && style !== void 0 && style.top ? 0 : undefined,
         // The cell's row will handle top positioning
         width: width,
         // column width, can be undefined

package/optimize/es/components/datagrid/body/data_grid_cell_wrapper.js

@@ -0,0 +1,127 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["colIndex", "visibleRowIndex", "style", "schema", "schemaDetectors", "pagination", "columns", "leadingControlColumns", "trailingControlColumns", "visibleColCount", "columnWidths", "defaultColumnWidth", "renderCellValue", "renderCellPopover", "interactiveCellId", "setRowHeight", "rowHeightsOptions", "rowHeightUtils", "rowManager"];
+
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+import React, { useContext, useMemo } from 'react';
+import classNames from 'classnames';
+import { DataGridSortingContext } from '../utils/sorting';
+import { DataGridCellPopoverContext } from './data_grid_cell_popover';
+import { EuiDataGridCell } from './data_grid_cell';
+import { jsx as ___EmotionJSX } from "@emotion/react";
+
+/**
+ * A DRY wrapper used by both custom and virtualized grid cells.
+ * It grabs context,  determines the type of cell being rendered
+ * (e.g. control vs data cell), & sets shared props between all cells
+ */
+export var Cell = function Cell(_ref) {
+  var colIndex = _ref.colIndex,
+      visibleRowIndex = _ref.visibleRowIndex,
+      style = _ref.style,
+      schema = _ref.schema,
+      schemaDetectors = _ref.schemaDetectors,
+      pagination = _ref.pagination,
+      columns = _ref.columns,
+      leadingControlColumns = _ref.leadingControlColumns,
+      trailingControlColumns = _ref.trailingControlColumns,
+      visibleColCount = _ref.visibleColCount,
+      columnWidths = _ref.columnWidths,
+      defaultColumnWidth = _ref.defaultColumnWidth,
+      renderCellValue = _ref.renderCellValue,
+      renderCellPopover = _ref.renderCellPopover,
+      interactiveCellId = _ref.interactiveCellId,
+      setRowHeight = _ref.setRowHeight,
+      rowHeightsOptions = _ref.rowHeightsOptions,
+      rowHeightUtils = _ref.rowHeightUtils,
+      rowManager = _ref.rowManager,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  var popoverContext = useContext(DataGridCellPopoverContext);
+
+  var _useContext = useContext(DataGridSortingContext),
+      getCorrectRowIndex = _useContext.getCorrectRowIndex;
+
+  var cellContent;
+  var isFirstColumn = colIndex === 0;
+  var isLastColumn = colIndex === visibleColCount - 1;
+  var isLeadingControlColumn = colIndex < leadingControlColumns.length;
+  var isTrailingControlColumn = colIndex >= leadingControlColumns.length + columns.length;
+  var datacolIndex = colIndex - leadingControlColumns.length;
+  var column = columns[datacolIndex];
+  var columnId = column === null || column === void 0 ? void 0 : column.id;
+  var textTransform = useMemo(function () {
+    var _schemaDetectors$filt;
+
+    return (_schemaDetectors$filt = schemaDetectors.filter(function (row) {
+      return column !== null && column !== void 0 && column.schema ? (column === null || column === void 0 ? void 0 : column.schema) === row.type : columnId === row.type;
+    })[0]) === null || _schemaDetectors$filt === void 0 ? void 0 : _schemaDetectors$filt.textTransform;
+  }, [columnId, column === null || column === void 0 ? void 0 : column.schema, schemaDetectors]);
+  var classes = classNames(_defineProperty({
+    'euiDataGridRowCell--firstColumn': isFirstColumn,
+    'euiDataGridRowCell--lastColumn': isLastColumn,
+    'euiDataGridRowCell--controlColumn': isLeadingControlColumn || isTrailingControlColumn
+  }, "euiDataGridRowCell--".concat(textTransform), textTransform));
+  var sharedCellProps = {
+    rowIndex: getCorrectRowIndex(visibleRowIndex),
+    visibleRowIndex: visibleRowIndex,
+    colIndex: colIndex,
+    interactiveCellId: interactiveCellId,
+    className: classes,
+    style: style,
+    rowHeightsOptions: rowHeightsOptions,
+    rowHeightUtils: rowHeightUtils,
+    setRowHeight: isFirstColumn ? setRowHeight : undefined,
+    rowManager: rowManager,
+    popoverContext: popoverContext,
+    pagination: pagination
+  };
+
+  if (isLeadingControlColumn) {
+    var leadingColumn = leadingControlColumns[colIndex];
+    var id = leadingColumn.id,
+        rowCellRender = leadingColumn.rowCellRender;
+    cellContent = ___EmotionJSX(EuiDataGridCell, _extends({}, sharedCellProps, {
+      columnId: id,
+      width: leadingColumn.width,
+      renderCellValue: rowCellRender,
+      isExpandable: false
+    }, rest));
+  } else if (isTrailingControlColumn) {
+    var columnOffset = columns.length + leadingControlColumns.length;
+    var trailingcolIndex = colIndex - columnOffset;
+    var trailingColumn = trailingControlColumns[trailingcolIndex];
+    var _id = trailingColumn.id,
+        _rowCellRender = trailingColumn.rowCellRender;
+    cellContent = ___EmotionJSX(EuiDataGridCell, _extends({}, sharedCellProps, {
+      columnId: _id,
+      width: trailingColumn.width,
+      renderCellValue: _rowCellRender,
+      isExpandable: false
+    }, rest));
+  } else {
+    // this is a normal data cell
+    var columnType = schema[columnId] ? schema[columnId].columnType : null;
+    var isExpandable = column.isExpandable !== undefined ? column.isExpandable : true;
+    var width = columnWidths[columnId] || defaultColumnWidth;
+    cellContent = ___EmotionJSX(EuiDataGridCell, _extends({}, sharedCellProps, {
+      columnId: columnId,
+      column: column,
+      columnType: columnType,
+      width: width || undefined,
+      renderCellValue: renderCellValue,
+      renderCellPopover: renderCellPopover,
+      interactiveCellId: interactiveCellId,
+      isExpandable: isExpandable
+    }, rest));
+  }
+
+  return cellContent;
+};

package/optimize/es/components/datagrid/body/header/data_grid_header_row.js

@@ -13,12 +13,13 @@ import classnames from 'classnames';
 import React, { forwardRef } from 'react';
 import { EuiDataGridControlHeaderCell } from './data_grid_control_header_cell';
 import { EuiDataGridHeaderCell } from './data_grid_header_cell';
+import { emptyControlColumns } from '../../data_grid_types';
 import { jsx as ___EmotionJSX } from "@emotion/react";
 var EuiDataGridHeaderRow = /*#__PURE__*/forwardRef(function (props, ref) {
   var _props$leadingControl = props.leadingControlColumns,
-      leadingControlColumns = _props$leadingControl === void 0 ? [] : _props$leadingControl,
+      leadingControlColumns = _props$leadingControl === void 0 ? emptyControlColumns : _props$leadingControl,
       _props$trailingContro = props.trailingControlColumns,
-      trailingControlColumns = _props$trailingContro === void 0 ? [] : _props$trailingContro,
+      trailingControlColumns = _props$trailingContro === void 0 ? emptyControlColumns : _props$trailingContro,
       columns = props.columns,
       schema = props.schema,
       schemaDetectors = props.schemaDetectors,

package/optimize/es/components/datagrid/data_grid.js

@@ -3,7 +3,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["leadingControlColumns", "trailingControlColumns", "columns", "columnVisibility", "schemaDetectors", "rowCount", "renderCellValue", "renderCellPopover", "renderFooterCellValue", "className", "gridStyle", "toolbarVisibility", "pagination", "sorting", "inMemory", "onColumnResize", "minSizeForControls", "height", "width", "rowHeightsOptions", "virtualizationOptions"],
+var _excluded = ["leadingControlColumns", "trailingControlColumns", "columns", "columnVisibility", "schemaDetectors", "rowCount", "renderCellValue", "renderCellPopover", "renderFooterCellValue", "className", "gridStyle", "toolbarVisibility", "pagination", "sorting", "inMemory", "onColumnResize", "minSizeForControls", "height", "width", "rowHeightsOptions", "virtualizationOptions", "renderCustomGridBody"],
     _excluded2 = ["focusProps"];
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
@@ -35,8 +35,9 @@ import { computeVisibleRows } from './utils/row_count';
 import { EuiDataGridPaginationRenderer } from './utils/data_grid_pagination';
 import { schemaDetectors as providedSchemaDetectors, useMergedSchema } from './utils/data_grid_schema';
 import { useImperativeGridRef } from './utils/ref';
+import { emptyControlColumns } from './data_grid_types'; // Each gridStyle object above sets a specific CSS select to .euiGrid
+
 import { jsx as ___EmotionJSX } from "@emotion/react";
-// Each gridStyle object above sets a specific CSS select to .euiGrid
 var fontSizesToClassMap = {
   s: 'euiDataGrid--fontSizeSmall',
   m: '',
@@ -69,9 +70,9 @@ export var EuiDataGrid = /*#__PURE__*/forwardRef(function (props, ref) {
   var _gridItemsRendered$cu;
 
   var _props$leadingControl = props.leadingControlColumns,
-      leadingControlColumns = _props$leadingControl === void 0 ? [] : _props$leadingControl,
+      leadingControlColumns = _props$leadingControl === void 0 ? emptyControlColumns : _props$leadingControl,
       _props$trailingContro = props.trailingControlColumns,
-      trailingControlColumns = _props$trailingContro === void 0 ? [] : _props$trailingContro,
+      trailingControlColumns = _props$trailingContro === void 0 ? emptyControlColumns : _props$trailingContro,
       columns = props.columns,
       columnVisibility = props.columnVisibility,
       schemaDetectors = props.schemaDetectors,
@@ -92,6 +93,7 @@ export var EuiDataGrid = /*#__PURE__*/forwardRef(function (props, ref) {
       width = props.width,
       _rowHeightsOptions = props.rowHeightsOptions,
       virtualizationOptions = props.virtualizationOptions,
+      renderCustomGridBody = props.renderCustomGridBody,
       rest = _objectWithoutProperties(props, _excluded);
   /**
    * Merge consumer settings with defaults
@@ -369,7 +371,8 @@ export var EuiDataGrid = /*#__PURE__*/forwardRef(function (props, ref) {
     gridWidth: gridWidth,
     gridRef: gridRef,
     gridItemsRendered: gridItemsRendered,
-    wrapperRef: contentRef
+    wrapperRef: contentRef,
+    renderCustomGridBody: renderCustomGridBody
   })), pagination && props['aria-labelledby'] && ___EmotionJSX("p", {
     id: ariaLabelledById,
     hidden: true

package/optimize/es/components/datagrid/data_grid_types.js

@@ -1 +1,18 @@
-export {};
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+// since react-window doesn't export a type with the imperative api only we can
+// use this to omit the react-specific class component methods
+// An array of [x,y] coordinates. Note that the `y` value expected internally is a `visibleRowIndex`
+// Force either aria-label or aria-labelledby to be defined
+
+/**
+ * Props shared between renderCellValue and renderCellPopover
+ */
+// The empty control column array fallbacks need to be cached, or
+// they'll cause rerendering/remount issues in memoized dependencies
+export var emptyControlColumns = [];