@carbon/ibm-products 1.27.0 → 1.32.0

package/es/components/Datagrid/Datagrid/addons/InlineEdit/handleGridKeyPress.js

@@ -0,0 +1,263 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * Copyright IBM Corp. 2022, 2022
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { carbon, pkg } from '../../../../../settings';
+import { handleMultipleKeys } from './handleMultipleKeys';
+import { getCellIdAsObject } from './InlineEditContext/getCellIdAsObject';
+var blockClass = "".concat(pkg.prefix, "--datagrid");
+export var handleGridKeyPress = function handleGridKeyPress(_ref) {
+  var event = _ref.event,
+      dispatch = _ref.dispatch,
+      state = _ref.state,
+      instance = _ref.instance,
+      keysPressedList = _ref.keysPressedList,
+      usingMac = _ref.usingMac;
+  var key = event.key;
+  var gridActive = state.gridActive,
+      activeCellId = state.activeCellId,
+      editId = state.editId;
+  var focusedCell = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit [data-cell-id=\"").concat(activeCellId, "\"]")); // If we reach this it means that tab was pressed while in
+  // edit mode which should not remove the focus from the grid
+
+  if (activeCellId === editId && key === 'Tab') {
+    // Attempting to exit date picker
+    if (focusedCell.getAttribute('data-inline-type') === 'date') {
+      dispatch({
+        type: 'EXIT_EDIT_MODE',
+        payload: activeCellId
+      });
+    }
+
+    event.preventDefault();
+    var inlineEditArea = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit"));
+    inlineEditArea.focus();
+    return;
+  }
+
+  if (activeCellId === editId && key === 'Escape') {
+    if (focusedCell.getAttribute('data-inline-type') === 'date') {
+      dispatch({
+        type: 'EXIT_EDIT_MODE',
+        payload: activeCellId
+      });
+      event.preventDefault();
+
+      var _inlineEditArea = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit"));
+
+      _inlineEditArea.focus();
+
+      return;
+    }
+  } // Checks if the dropdown menu is open
+
+
+  var dropdownIsActive = function dropdownIsActive() {
+    var focusedElementRole = document.activeElement.getAttribute('role');
+
+    if (focusedElementRole === 'listbox' && document.activeElement.classList.contains("".concat(carbon.prefix, "--list-box__menu"))) {
+      // Prevents arrow keys from scrolling any other content when dropdown menu is open
+      event.preventDefault();
+      return true;
+    }
+
+    return false;
+  }; // Checks if the date picker is open
+
+
+  var datePickerIsActive = function datePickerIsActive() {
+    var focusedCalendarElement = document.querySelector(".".concat(carbon.prefix, "--date-picker__input.flatpickr-input.active"));
+
+    if (focusedCalendarElement || document.activeElement.classList.contains("flatpickr-day")) {
+      event.preventDefault();
+      return true;
+    }
+
+    return false;
+  }; // Stop grid key listener when in edit mode
+
+
+  var isEditing = document.activeElement.id === activeCellId && document.activeElement.id === editId || dropdownIsActive() || datePickerIsActive();
+
+  if (isEditing || !gridActive) {
+    return;
+  } // Command keys need to be returned as there is default browser behavior with these keys
+
+
+  if (key === 'Meta' || key === 'Control') {
+    return;
+  } // Prevent arrow keys, home key, and end key from scrolling the page when the data spreadsheet container has focus
+
+
+  if (['End', 'Home', 'ArrowLeft', 'ArrowUp', 'ArrowRight', 'ArrowDown'].indexOf(key) > -1 && !isEditing && keysPressedList.length < 2) {
+    event.preventDefault();
+  }
+
+  var isDisabledCell = !!focusedCell.getAttribute('data-disabled');
+  var sharedUpdateParams = {
+    oldId: activeCellId,
+    instance: instance
+  };
+
+  if (keysPressedList.length > 1) {
+    handleMultipleKeys({
+      usingMac: usingMac,
+      keysPressedList: keysPressedList,
+      dispatch: dispatch,
+      activeCellId: activeCellId,
+      instance: instance
+    });
+  }
+
+  if (keysPressedList.length < 2) {
+    switch (key) {
+      case 'Tab':
+        {
+          if (!editId) {
+            dispatch({
+              type: 'REMOVE_GRID_ACTIVE_FOCUS',
+              payload: activeCellId
+            });
+          }
+
+          break;
+        }
+
+      case 'ArrowRight':
+        {
+          dispatch({
+            type: 'UPDATE_ACTIVE_CELL_ID',
+            payload: _objectSpread({
+              direction: 'right'
+            }, sharedUpdateParams)
+          });
+          break;
+        }
+
+      case 'ArrowLeft':
+        {
+          dispatch({
+            type: 'UPDATE_ACTIVE_CELL_ID',
+            payload: _objectSpread({
+              direction: 'left'
+            }, sharedUpdateParams)
+          });
+          break;
+        }
+
+      case 'ArrowUp':
+        {
+          dispatch({
+            type: 'UPDATE_ACTIVE_CELL_ID',
+            payload: _objectSpread({
+              direction: 'up'
+            }, sharedUpdateParams)
+          });
+          break;
+        }
+
+      case 'ArrowDown':
+        {
+          dispatch({
+            type: 'UPDATE_ACTIVE_CELL_ID',
+            payload: _objectSpread({
+              direction: 'down'
+            }, sharedUpdateParams)
+          });
+          break;
+        }
+      // Move active cell to first column in current row
+
+      case 'Home':
+        {
+          var activeCellObject = getCellIdAsObject(activeCellId);
+
+          var newActiveCellCoords = _objectSpread(_objectSpread({}, activeCellObject), {}, {
+            column: 0
+          });
+
+          var newActiveCellId = "column-".concat(newActiveCellCoords.column, "-row-").concat(newActiveCellCoords.row);
+          var scrollElement = document.querySelector("#".concat(instance.tableId, " .").concat(pkg.prefix, "--datagrid__table-container")); // Scroll table container to the furthest left position
+
+          scrollElement.scrollLeft = 0;
+          dispatch({
+            type: 'UPDATE_ACTIVE_CELL_ID',
+            payload: newActiveCellId
+          });
+          break;
+        }
+      // Move active cell to last column in current row
+
+      case 'End':
+        {
+          var _activeCellObject = getCellIdAsObject(activeCellId);
+
+          var totalVisibleColumns = instance.visibleColumns.filter(function (item) {
+            return item.id !== 'spacer';
+          });
+
+          var _newActiveCellCoords = _objectSpread(_objectSpread({}, _activeCellObject), {}, {
+            column: totalVisibleColumns.length - 1
+          });
+
+          var _newActiveCellId = "column-".concat(_newActiveCellCoords.column, "-row-").concat(_newActiveCellCoords.row);
+
+          var _scrollElement = document.querySelector("#".concat(instance.tableId, " .").concat(pkg.prefix, "--datagrid__table-container")); // Scroll table container to the furthest right position
+
+
+          _scrollElement.scrollLeft = _scrollElement.scrollWidth;
+          dispatch({
+            type: 'UPDATE_ACTIVE_CELL_ID',
+            payload: _newActiveCellId
+          });
+          break;
+        }
+
+      case ' ':
+      case 'F2':
+      case 'Enter':
+        {
+          // Disabled cells are not allowed to go into edit mode
+          if (isDisabledCell) {
+            return;
+          } // Only go into edit mode if there is no editId, meaning that we're not already in edit mode
+
+
+          if (!editId) {
+            var focusedType = focusedCell.getAttribute('data-inline-type'); // Open dropdown immediately after entering edit mode for selection type
+
+            if (focusedType === 'selection') {
+              setTimeout(function () {
+                var dropdownTrigger = focusedCell.querySelector('button');
+                dropdownTrigger === null || dropdownTrigger === void 0 ? void 0 : dropdownTrigger.click();
+              }, 1);
+            }
+
+            if (focusedType === 'date') {
+              setTimeout(function () {
+                var dateInputTrigger = focusedCell.querySelector('input');
+                dateInputTrigger === null || dateInputTrigger === void 0 ? void 0 : dateInputTrigger.click();
+                dateInputTrigger === null || dateInputTrigger === void 0 ? void 0 : dateInputTrigger.focus();
+              }, 1);
+            }
+
+            dispatch({
+              type: 'ENTER_EDIT_MODE',
+              payload: {
+                activeCellId: activeCellId,
+                editId: activeCellId
+              }
+            });
+          }
+        }
+    }
+  }
+};

package/es/components/Datagrid/Datagrid/addons/InlineEdit/handleMultipleKeys.js

@@ -0,0 +1,66 @@
+/**
+ * Copyright IBM Corp. 2022, 2022
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { includesResourceKey } from '../../../../DataSpreadsheet/utils/handleMultipleKeys';
+import { pkg } from '../../../../../settings';
+var blockClass = "".concat(pkg.prefix, "--datagrid");
+export var handleMultipleKeys = function handleMultipleKeys(_ref) {
+  var usingMac = _ref.usingMac,
+      keysPressedList = _ref.keysPressedList,
+      dispatch = _ref.dispatch,
+      activeCellId = _ref.activeCellId,
+      instance = _ref.instance;
+
+  // Resource key and Home
+  // Move active cell to first cell in first row and column
+  if (includesResourceKey(keysPressedList, usingMac) && keysPressedList.includes('Home')) {
+    var scrollElement = document.querySelector("#".concat(instance.tableId, " .").concat(pkg.prefix, "--datagrid__table-container")); // Scroll table container to the furthest top left position
+
+    scrollElement.scrollTop = 0;
+    scrollElement.scrollLeft = 0;
+    dispatch({
+      type: 'UPDATE_ACTIVE_CELL_ID',
+      payload: 'column-0-row-0'
+    });
+  } // Resource key and End
+  // Move active cell to last cell in in the last row and column
+
+
+  if (includesResourceKey(keysPressedList, usingMac) && keysPressedList.includes('End')) {
+    var _instance$rows;
+
+    var totalVisibleColumns = instance.visibleColumns.filter(function (item) {
+      return item.id !== 'spacer';
+    }).length;
+    var totalRows = (_instance$rows = instance.rows) === null || _instance$rows === void 0 ? void 0 : _instance$rows.length;
+    var lastCellDataId = "column-".concat(totalVisibleColumns - 1, "-row-").concat(totalRows - 1);
+    var lastCellElement = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit [data-cell-id=\"").concat(activeCellId, "\"]"));
+
+    var _scrollElement = document.querySelector("#".concat(instance.tableId, " .").concat(pkg.prefix, "--datagrid__table-container")); // Scroll table container to the furthest bottom right position
+
+
+    _scrollElement.scrollTop = _scrollElement.scrollHeight;
+    _scrollElement.scrollLeft = _scrollElement.scrollWidth;
+
+    if (lastCellElement) {
+      dispatch({
+        type: 'UPDATE_ACTIVE_CELL_ID',
+        payload: lastCellDataId
+      });
+    } else {
+      // If a Datagrid component is using virtualized data, it's possible that the last cell
+      // has not yet been rendered. In this case, we simply need to wait until the scrollable
+      // container has scrolled to the bottom/right most position, then we can dispatch the
+      // update active cell id action
+      setTimeout(function () {
+        dispatch({
+          type: 'UPDATE_ACTIVE_CELL_ID',
+          payload: lastCellDataId
+        });
+      }, 250);
+    }
+  }
+};

package/es/components/Datagrid/Datagrid/addons/RowSize/RowSizeDropdown.js

@@ -2,7 +2,7 @@ import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["buttonLabel"];
+var _excluded = ["legendText"];
 // @flow
 
 /*
@@ -22,8 +22,8 @@ import { pkg } from '../../../../../settings';
 var blockClass = "".concat(pkg.prefix, "--datagrid");
 
 var RowSizeDropdown = function RowSizeDropdown(_ref) {
-  var _ref$buttonLabel = _ref.buttonLabel,
-      buttonLabel = _ref$buttonLabel === void 0 ? 'Row height' : _ref$buttonLabel,
+  var _ref$legendText = _ref.legendText,
+      legendText = _ref$legendText === void 0 ? 'Row height' : _ref$legendText,
       props = _objectWithoutProperties(_ref, _excluded);
 
   var buttonRef = React.useRef({});
@@ -42,9 +42,10 @@ var RowSizeDropdown = function RowSizeDropdown(_ref) {
     onClick: function onClick() {
       return setIsOpen(!isOpen);
     },
-    iconDescription: buttonLabel,
+    iconDescription: legendText,
     className: cx(_defineProperty({}, "".concat(blockClass, "__row-size-button--open"), isOpen))
   }), isOpen && /*#__PURE__*/React.createElement(RowSizeRadioGroup, _extends({}, props, {
+    legendText: legendText,
     buttonRef: buttonRef,
     hideRadioGroup: function hideRadioGroup() {
       setIsOpen(false);
@@ -53,8 +54,8 @@ var RowSizeDropdown = function RowSizeDropdown(_ref) {
 };
 
 RowSizeDropdown.propTypes = {
-  buttonLabel: PropTypes.string,
   datagridName: PropTypes.string,
+  legendText: PropTypes.string,
   light: PropTypes.bool,
   onChange: PropTypes.func.isRequired,
   selectedOption: PropTypes.string

package/es/components/Datagrid/Datagrid/addons/RowSize/RowSizeRadioGroup.js

@@ -22,8 +22,7 @@ var RowSizeRadioGroup = function RowSizeRadioGroup(_ref) {
       buttonRef = _ref.buttonRef,
       onChange = _ref.onChange,
       hideRadioGroup = _ref.hideRadioGroup,
-      _ref$legendText = _ref.legendText,
-      legendText = _ref$legendText === void 0 ? 'Row height' : _ref$legendText,
+      legendText = _ref.legendText,
       _ref$rowSizeLabels = _ref.rowSizeLabels,
       rowSizeLabels = _ref$rowSizeLabels === void 0 ? {
     xl: 'Extra large',

package/es/components/Datagrid/index.js

@@ -20,4 +20,6 @@ export { default as useStickyColumn } from './useStickyColumn';
 export { default as useActionsColumn } from './useActionsColumn';
 export { default as useCustomizeColumns } from './useCustomizeColumns';
 export { default as useSelectAllWithToggle } from './useSelectAllToggle';
-export { default as useColumnCenterAlign } from './useColumnCenterAlign';
+export { default as useColumnCenterAlign } from './useColumnCenterAlign';
+export { default as useColumnOrder } from './useColumnOrder';
+export { default as useInlineEdit } from './useInlineEdit';

package/es/components/Datagrid/useActionsColumn.js

@@ -1,7 +1,8 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["id", "onClick", "shouldHideMenuItem", "shouldDisableMenuItem", "disabled"];
+var _excluded = ["id", "itemText", "onClick", "icon"],
+    _excluded2 = ["id", "onClick", "shouldHideMenuItem", "shouldDisableMenuItem", "disabled"];
 
 /*
  * Licensed Materials - Property of IBM
@@ -19,7 +20,8 @@ var blockClass = "".concat(pkg.prefix, "--datagrid");
 var useActionsColumn = function useActionsColumn(hooks) {
   var useAttachActionsOnInstance = function useAttachActionsOnInstance(instance) {
     var rowActions = instance.rowActions,
-        isFetching = instance.isFetching;
+        isFetching = instance.isFetching,
+        selectedFlatRows = instance.selectedFlatRows;
 
     if (rowActions && Array.isArray(rowActions)) {
       var addActionsMenu = function addActionsMenu(props, cellData) {
@@ -28,7 +30,7 @@ var useActionsColumn = function useActionsColumn(hooks) {
             column = cell.column;
 
         if (column.isAction) {
-          var _cx;
+          var _cx3;
 
           return [props, {
             children: /*#__PURE__*/React.createElement("div", {
@@ -40,26 +42,37 @@ var useActionsColumn = function useActionsColumn(hooks) {
               style: {
                 display: 'flex'
               }
-            }, rowActions.map(function (action) {
+            }, rowActions.map(function (action, index) {
               var id = action.id,
                   itemText = action.itemText,
                   _onClick = action.onClick,
-                  icon = action.icon;
+                  icon = action.icon,
+                  rest = _objectWithoutProperties(action, _excluded);
+
+              var selectedRowId = selectedFlatRows === null || selectedFlatRows === void 0 ? void 0 : selectedFlatRows.filter(function (item) {
+                return item.id === row.id ? item.id : null;
+              });
               return /*#__PURE__*/React.createElement("div", {
-                className: "".concat(blockClass, "__actions-column-button"),
-                key: ""
-              }, /*#__PURE__*/React.createElement(OverflowMenu, {
+                className: cx("".concat(blockClass, "__actions-column-button"), _defineProperty({}, "".concat(blockClass, "__disabled-row-action-button"), selectedFlatRows && selectedFlatRows.length && selectedRowId && selectedRowId.length)),
+                key: "".concat(itemText, "__").concat(index)
+              }, /*#__PURE__*/React.createElement(OverflowMenu, _extends({}, rest, {
                 renderIcon: icon,
                 hasIconOnly: true,
                 light: true,
                 iconDescription: itemText,
                 kind: "ghost",
+                className: cx(_defineProperty({}, "".concat(blockClass, "__disabled-row-action"), selectedFlatRows && selectedFlatRows.length && selectedRowId && selectedRowId.length)),
                 onClick: function onClick(e) {
+                  if (selectedFlatRows && selectedFlatRows.length && selectedRowId && selectedRowId.length) {
+                    // Row actions should be disabled if row is selected and batchActions toolbar is active
+                    return;
+                  }
+
                   e.stopPropagation();
 
                   _onClick(id, row, e);
                 }
-              }));
+              })));
             })), !isFetching && rowActions.length > 2 && /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(OverflowMenu, {
               size: "sm",
               light: true,
@@ -73,7 +86,7 @@ var useActionsColumn = function useActionsColumn(hooks) {
                   shouldHideMenuItem = action.shouldHideMenuItem,
                   shouldDisableMenuItem = action.shouldDisableMenuItem,
                   disabled = action.disabled,
-                  rest = _objectWithoutProperties(action, _excluded);
+                  rest = _objectWithoutProperties(action, _excluded2);
 
               var hidden = typeof shouldHideMenuItem === 'function' && shouldHideMenuItem(row); // shouldDisableMenuItem will override disabled because it's more specific
               // if shouldDisableMenuItem doesn't exists, fall back to disabled
@@ -94,7 +107,10 @@ var useActionsColumn = function useActionsColumn(hooks) {
                 key: id
               }));
             })))),
-            className: cx((_cx = {}, _defineProperty(_cx, "".concat(blockClass, "__actions-column-cell"), true), _defineProperty(_cx, "".concat(blockClass, "__cell"), true), _cx))
+            className: cx((_cx3 = {}, _defineProperty(_cx3, "".concat(blockClass, "__actions-column-cell"), true), _defineProperty(_cx3, "".concat(blockClass, "__cell"), true), _cx3)),
+            style: {
+              width: 96
+            }
           }];
         }
 

package/es/components/Datagrid/useColumnOrder.js

@@ -0,0 +1,8 @@
+/**
+ * Copyright IBM Corp. 2022, 2022
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { useColumnOrder } from 'react-table';
+export default useColumnOrder;

package/es/components/Datagrid/useCustomizeColumns.js

@@ -26,6 +26,10 @@ var useCustomizeColumns = function useCustomizeColumns(hooks) {
 
   hooks.useInstance.push(function (instance) {
     var customizeColumnsProps = instance.customizeColumnsProps;
+
+    var _ref = customizeColumnsProps || {},
+        labels = _ref.labels;
+
     Object.assign(instance, {
       customizeColumnsProps: _objectSpread(_objectSpread({}, customizeColumnsProps), {}, {
         isModalOpen: isModalOpen,
@@ -33,6 +37,7 @@ var useCustomizeColumns = function useCustomizeColumns(hooks) {
       }),
       CustomizeColumnsButton: function CustomizeColumnsButton(props) {
         return /*#__PURE__*/React.createElement(ToggleButtonWrapper, _extends({
+          iconTooltipLabel: labels === null || labels === void 0 ? void 0 : labels.iconTooltipLabel,
           isModalOpen: isModalOpen,
           setIsModalOpen: setIsModalOpen
         }, props));

package/es/components/Datagrid/useDisableSelectRows.js

@@ -22,6 +22,8 @@ var useDisableSelectRows = function useDisableSelectRows(hooks) {
 
 var updateSelectAll = function updateSelectAll(hooks) {
   var getToggleAllRowsSelectedProps = function getToggleAllRowsSelectedProps(props, _ref2) {
+    var _instance$disableSele, _instance$disableSele2;
+
     var instance = _ref2.instance;
     var selectableRows = instance.rows.filter(function (row) {
       return !(instance.shouldDisableSelectRow && instance.shouldDisableSelectRow(row));
@@ -41,7 +43,7 @@ var updateSelectAll = function updateSelectAll(hooks) {
       },
       checked: isAllRowsSelected,
       disabled: instance.disableSelectAll,
-      title: 'Toggle All Rows Selected',
+      title: (instance === null || instance === void 0 ? void 0 : (_instance$disableSele = instance.disableSelectRowsProps) === null || _instance$disableSele === void 0 ? void 0 : (_instance$disableSele2 = _instance$disableSele.labels) === null || _instance$disableSele2 === void 0 ? void 0 : _instance$disableSele2.toggleAllRowsLabel) || 'Toggle All Rows Selected',
       indeterminate: Boolean(!isAllRowsSelected && Object.keys(instance.state.selectedRowIds).length)
     }];
   };
@@ -51,6 +53,8 @@ var updateSelectAll = function updateSelectAll(hooks) {
 
 var updatePageSelectAll = function updatePageSelectAll(hooks) {
   var getToggleAllPageRowsSelectedProps = function getToggleAllPageRowsSelectedProps(props, _ref4) {
+    var _instance$disableSele3, _instance$disableSele4;
+
     var instance = _ref4.instance;
     var selectableRows = instance.page.filter(function (row) {
       return !(instance.shouldDisableSelectRow && instance.shouldDisableSelectRow(row));
@@ -70,7 +74,7 @@ var updatePageSelectAll = function updatePageSelectAll(hooks) {
       },
       checked: isAllRowsSelected,
       disabled: instance.disableSelectAll,
-      title: 'Toggle All Rows Selected',
+      title: (instance === null || instance === void 0 ? void 0 : (_instance$disableSele3 = instance.disableSelectRowsProps) === null || _instance$disableSele3 === void 0 ? void 0 : (_instance$disableSele4 = _instance$disableSele3.labels) === null || _instance$disableSele4 === void 0 ? void 0 : _instance$disableSele4.toggleAllRowsLabel) || 'Toggle All Rows Selected',
       indeterminate: Boolean(!isAllRowsSelected && instance.page.some(function (_ref6) {
         var id = _ref6.id;
         return instance.state.selectedRowIds[id];

package/es/components/Datagrid/useExpandedRow.js

@@ -37,7 +37,6 @@ var useExpandedRow = function useExpandedRow(hooks) {
       return _objectSpread(_objectSpread({}, row), {}, {
         canExpand: row.original && !row.original.notExpandable,
         expandedContentHeight: expandedRowsHeight[row.index] || expandedContentHeight,
-        // RowRenderer: DatagridExpandedRow(row.RowRenderer, expansionRenderer),
         RowRenderer: DatagridExpandedRow(row.RowRenderer, ExpandedRowContentComponent)
       });
     });

package/es/components/Datagrid/useInlineEdit.js

@@ -0,0 +1,71 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2022
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import React from 'react';
+import { pkg } from '../../settings';
+import cx from 'classnames';
+import { InlineEditCell } from './Datagrid/addons/InlineEdit/InlineEditCell';
+var blockClass = "".concat(pkg.prefix, "--datagrid");
+
+var useInlineEdit = function useInlineEdit(hooks) {
+  var addInlineEdit = function addInlineEdit(props, _ref) {
+    var _cell$column, _cell$column$inlineEd, _instance$columns$fil;
+
+    var cell = _ref.cell,
+        instance = _ref.instance;
+    var columnInlineEditConfig = cell.column.inlineEdit;
+    var inlineEditType = (_cell$column = cell.column) === null || _cell$column === void 0 ? void 0 : (_cell$column$inlineEd = _cell$column.inlineEdit) === null || _cell$column$inlineEd === void 0 ? void 0 : _cell$column$inlineEd.type;
+    var totalInlineEditColumns = (_instance$columns$fil = instance.columns.filter(function (item) {
+      return item.inlineEdit;
+    })) === null || _instance$columns$fil === void 0 ? void 0 : _instance$columns$fil.length;
+
+    var renderInlineEditComponent = function renderInlineEditComponent(type) {
+      return /*#__PURE__*/React.createElement(InlineEditCell, {
+        config: columnInlineEditConfig,
+        tabIndex: -1,
+        value: cell.value,
+        cell: cell,
+        instance: instance,
+        totalInlineEditColumns: totalInlineEditColumns,
+        type: type
+      });
+    };
+
+    if (cell.column.id === 'spacer') {
+      return [props, {
+        className: cx("".concat(blockClass, "__cell"), "".concat(blockClass, "__cell--spacer"))
+      }];
+    }
+
+    return [props, {
+      className: cx("".concat(blockClass, "__cell"), _defineProperty({}, "".concat(blockClass, "__cell-inline-edit"), true)),
+      role: 'gridcell',
+      children: /*#__PURE__*/React.createElement(React.Fragment, null, inlineEditType === 'text' && renderInlineEditComponent(inlineEditType), inlineEditType === 'number' && renderInlineEditComponent(inlineEditType), inlineEditType === 'selection' && renderInlineEditComponent(inlineEditType), inlineEditType === 'date' && renderInlineEditComponent(inlineEditType), !inlineEditType && /*#__PURE__*/React.createElement(InlineEditCell, {
+        config: columnInlineEditConfig,
+        tabIndex: -1,
+        value: cell.value,
+        cell: cell,
+        instance: instance,
+        disabled: true,
+        nonEditCell: true,
+        totalInlineEditColumns: totalInlineEditColumns,
+        type: "text"
+      }))
+    }];
+  };
+
+  hooks.getCellProps.push(addInlineEdit);
+  hooks.useInstance.push(function (instance) {
+    Object.assign(instance, {
+      withInlineEdit: true
+    });
+  });
+};
+
+export default useInlineEdit;

package/es/components/Datagrid/useNestedRowExpander.js

@@ -0,0 +1,42 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+/* eslint-disable react/prop-types */
+
+/*
+ * Licensed Materials - Property of IBM
+ * 5724-Q36
+ * (c) Copyright IBM Corp. 2020
+ * US Government Users Restricted Rights - Use, duplication or disclosure
+ * restricted by GSA ADP Schedule Contract with IBM Corp.
+ */
+import React from 'react';
+import { ChevronRight16 } from '@carbon/icons-react';
+import cx from 'classnames';
+import { pkg } from '../../settings';
+var blockClass = "".concat(pkg.prefix, "--datagrid");
+
+var useNestedRowExpander = function useNestedRowExpander(hooks) {
+  var visibleColumns = function visibleColumns(columns) {
+    var expanderColumn = {
+      id: 'expander',
+      Cell: function Cell(_ref) {
+        var _cx;
+
+        var row = _ref.row;
+        return row.canExpand && /*#__PURE__*/React.createElement("span", row.getToggleRowExpandedProps(), /*#__PURE__*/React.createElement(ChevronRight16, {
+          className: cx("".concat(blockClass, "__expander-icon"), (_cx = {}, _defineProperty(_cx, "".concat(blockClass, "__expander-icon--not-open"), !row.isExpanded), _defineProperty(_cx, "".concat(blockClass, "__expander-icon--open"), row.isExpanded), _cx))
+        }));
+      },
+      width: 48,
+      disableResizing: true,
+      disableSortBy: true,
+      Header: ''
+    };
+    return [expanderColumn].concat(_toConsumableArray(columns));
+  };
+
+  hooks.visibleColumns.push(visibleColumns);
+};
+
+export default useNestedRowExpander;