@carbon/ibm-products 2.0.0-rc.2 → 2.0.0-rc.20

package/es/components/Datagrid/Datagrid/addons/InlineEdit/InlineEditContext/returnUpdatedActiveCell.js

@@ -0,0 +1,39 @@
+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 { pkg } from '../../../../../../settings';
+var blockClass = "".concat(pkg.prefix, "--datagrid"); // This function returns the state back to the reducer after
+// determining the new active cell value
+
+export var returnUpdatedActiveCell = function returnUpdatedActiveCell(_ref) {
+  var activeCellCoords = _ref.activeCellCoords,
+      direction = _ref.direction,
+      totalVisibleColumns = _ref.totalVisibleColumns,
+      state = _ref.state,
+      instance = _ref.instance;
+
+  var newActiveCoords = _objectSpread(_objectSpread({}, activeCellCoords), {}, {
+    column: direction === 'right' ? activeCellCoords.column < totalVisibleColumns.length - 1 ? activeCellCoords.column + 1 : activeCellCoords.column : direction === 'left' ? activeCellCoords.column === 0 ? 0 : activeCellCoords.column - 1 : activeCellCoords.column,
+    row: direction === 'up' ? activeCellCoords.row === 0 ? 0 : activeCellCoords.row - 1 : direction === 'down' ? activeCellCoords.row < instance.rows.length - 1 ? activeCellCoords.row + 1 : activeCellCoords.row : activeCellCoords.row
+  });
+
+  var newActiveCellId = "column-".concat(newActiveCoords.column, "-row-").concat(newActiveCoords.row);
+  var newCellIdButton = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit [data-cell-id=\"").concat(newActiveCellId, "\"] .").concat(blockClass, "__inline-edit-button")); // Allows scrollable area to keep focused/active cell id visible
+
+  if (newCellIdButton) {
+    newCellIdButton === null || newCellIdButton === void 0 ? void 0 : newCellIdButton.focus();
+  }
+
+  return _objectSpread(_objectSpread({}, state), {}, {
+    activeCellId: newActiveCellId
+  });
+};

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

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+export var handleGridFocus = function handleGridFocus(state, dispatch) {
+  var gridActive = state.gridActive,
+      previousActiveCellId = state.previousActiveCellId;
+
+  if (!gridActive) {
+    // Initialize grid active state
+    dispatch({
+      type: 'ADD_GRID_ACTIVE_FOCUS',
+      payload: previousActiveCellId || 'column-0-row-0' // If there is a previous active cell id that is found use that, otherwise use the first cell in the grid area
+
+    });
+  }
+};

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

@@ -0,0 +1,262 @@
+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
+      });
+      var inlineEditArea = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit"));
+      inlineEditArea.focus();
+    }
+
+    event.preventDefault();
+    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")) {
+      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,87 @@
+/**
+ * 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';
+import { getFocusableElements } from '../../../../../global/js/utils/getFocusableElements';
+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);
+    }
+  } // Shift + Tab
+  // This should remove the active grid state
+
+
+  if ((keysPressedList.includes('ShiftLeft') || keysPressedList.includes('ShiftRight')) && keysPressedList.includes('Tab')) {
+    dispatch({
+      type: 'REMOVE_GRID_ACTIVE_FOCUS',
+      payload: activeCellId
+    });
+    var tableElement = document.querySelector("#".concat(instance.tableId));
+    var datagridFocusableElements = getFocusableElements(tableElement);
+    var indexOfTable = datagridFocusableElements.findIndex(function (item) {
+      return item instanceof HTMLTableElement;
+    });
+
+    if (indexOfTable && Number.isFinite(indexOfTable)) {
+      var _datagridFocusableEle;
+
+      (_datagridFocusableEle = datagridFocusableElements[indexOfTable]) === null || _datagridFocusableEle === void 0 ? void 0 : _datagridFocusableEle.focus();
+    }
+  }
+};

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
 
 /*
@@ -14,47 +14,50 @@ var _excluded = ["buttonLabel"];
  */
 import * as React from 'react';
 import PropTypes from 'prop-types';
-import { Settings } from '@carbon/icons-react';
-import { IconButton } from '@carbon/react';
+import { Settings } from '@carbon/react/icons';
+import { IconButton, Popover, PopoverContent } from '@carbon/react';
 import cx from 'classnames';
 import RowSizeRadioGroup from './RowSizeRadioGroup';
 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({});
-
   var _React$useState = React.useState(false),
       _React$useState2 = _slicedToArray(_React$useState, 2),
       isOpen = _React$useState2[0],
       setIsOpen = _React$useState2[1];
 
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(IconButton, {
-    ref: buttonRef,
+  return /*#__PURE__*/React.createElement(Popover, {
+    align: "bottom-right",
+    caret: false,
+    dropShadow: false,
+    open: isOpen,
+    className: "".concat(blockClass, "__row-height-settings-popover")
+  }, /*#__PURE__*/React.createElement(IconButton, {
     kind: "ghost",
     align: "left",
     onClick: function onClick() {
       return setIsOpen(!isOpen);
     },
-    label: buttonLabel,
+    label: legendText,
     className: cx("".concat(blockClass, "__row-size-button"), _defineProperty({}, "".concat(blockClass, "__row-size-button--open"), isOpen))
   }, /*#__PURE__*/React.createElement(Settings, {
     size: 16
-  })), isOpen && /*#__PURE__*/React.createElement(RowSizeRadioGroup, _extends({}, props, {
-    ref: buttonRef,
+  })), /*#__PURE__*/React.createElement(PopoverContent, null, /*#__PURE__*/React.createElement(RowSizeRadioGroup, _extends({}, props, {
+    legendText: legendText,
     hideRadioGroup: function hideRadioGroup() {
       setIsOpen(false);
     }
-  })));
+  }))));
 };
 
 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

@@ -8,20 +8,21 @@
  * US Government Users Restricted Rights - Use, duplication or disclosure
  * restricted by GSA ADP Schedule Contract with IBM Corp.
  */
-import React, { useEffect, forwardRef } from 'react';
+import React, { useRef } from 'react';
 import PropTypes from 'prop-types';
 import { RadioButtonGroup, RadioButton } from '@carbon/react';
 import isArray from 'lodash/isArray';
 import { pkg } from '../../../../../settings';
+import { useClickOutside } from '../../../../../global/js/hooks';
 var blockClass = "".concat(pkg.prefix, "--datagrid");
-var RowSizeRadioGroup = /*#__PURE__*/forwardRef(function (_ref, ref) {
+
+var RowSizeRadioGroup = function RowSizeRadioGroup(_ref) {
   var rowSizes = _ref.rowSizes,
       selectedOption = _ref.selectedOption,
       datagridName = _ref.datagridName,
       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',
@@ -30,41 +31,17 @@ var RowSizeRadioGroup = /*#__PURE__*/forwardRef(function (_ref, ref) {
     sm: 'Small',
     xs: 'Extra small'
   } : _ref$rowSizeLabels;
-
-  var getDropdownPosition = function getDropdownPosition(buttonEle) {
-    if (buttonEle instanceof HTMLElement) {
-      var _top = buttonEle.offsetTop + buttonEle.offsetHeight;
-
-      var _right = buttonEle.offsetLeft + buttonEle.offsetWidth;
-
-      return {
-        top: _top,
-        right: _right
-      };
+  var popoverContentRef = useRef();
+  useClickOutside(popoverContentRef, function (target) {
+    if (target.closest(".".concat(blockClass, "__row-size-button"))) {
+      return;
     }
 
-    return {
-      top: 0,
-      right: 0
-    };
-  };
-
-  var _getDropdownPosition = getDropdownPosition(ref.current),
-      top = _getDropdownPosition.top,
-      right = _getDropdownPosition.right;
-
-  useEffect(function () {
-    window.addEventListener('click', hideRadioGroup);
-    return function () {
-      window.removeEventListener('click', hideRadioGroup);
-    };
-  }, [hideRadioGroup]);
+    hideRadioGroup();
+  });
   return /*#__PURE__*/React.createElement("div", {
+    ref: popoverContentRef,
     className: "".concat(blockClass, "__row-size-dropdown"),
-    style: {
-      top: top,
-      right: right
-    },
     role: "presentation",
     onClick: function onClick(e) {
       e.stopPropagation();
@@ -91,7 +68,7 @@ var RowSizeRadioGroup = /*#__PURE__*/forwardRef(function (_ref, ref) {
       id: "".concat(datagridName || 'datagrid', "--row-density--").concat(option.value)
     });
   })));
-});
+};
 
 var getBackwardCompatibleRowSize = function getBackwardCompatibleRowSize(rowSize) {
   // TODO: deprecate this function in next major release (v8) on carbon-components-react

package/es/components/Datagrid/{Datagrid.stories-helpers → Datagrid.stories}/index.js

@@ -1,5 +1,4 @@
 export { story as CustomizeColumnStoryNotes } from './CustomizeColumnStory';
 export { default as StickyActionsColumn } from './StickyActionsColumnStory';
 export { story as RowSizeDropdownStory } from './RowSizeDropdownStory';
-export { story as LeftPanelStory } from './LeftPanelStory';
 export { story as SelectAllWithToggle } from './SelectAllWithToggleStory';

package/es/components/Datagrid/index.js

@@ -20,4 +20,7 @@ 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';
+export { default as useFiltering } from './useFiltering';