@carbon/ibm-products 1.8.0 → 1.9.0

package/es/components/AddSelect/AddSelectColumn.js

@@ -0,0 +1,21 @@
+import _extends from "@babel/runtime/helpers/extends";
+//
+// Copyright IBM Corp. 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 React from 'react'; // import PropTypes from 'prop-types';
+
+import { pkg } from '../../settings';
+import { AddSelectList } from './AddSelectList';
+var componentName = 'AddSelect';
+export var AddSelectColumn = function AddSelectColumn(props) {
+  var blockClass = "".concat(pkg.prefix, "--add-select__col");
+  return /*#__PURE__*/React.createElement("div", {
+    className: blockClass
+  }, /*#__PURE__*/React.createElement(AddSelectList, _extends({}, props, {
+    inColumn: true
+  })));
+};
+AddSelectColumn.displayName = componentName;

package/es/components/AddSelect/AddSelectList.js

@@ -13,6 +13,7 @@ import { pkg } from '../../settings';
 var componentName = 'AddSelectList';
 export var AddSelectList = function AddSelectList(_ref) {
   var filteredItems = _ref.filteredItems,
+      inColumn = _ref.inColumn,
       multi = _ref.multi,
       multiSelection = _ref.multiSelection,
       path = _ref.path,
@@ -41,11 +42,61 @@ export var AddSelectList = function AddSelectList(_ref) {
 
   var onNavigateItem = function onNavigateItem(_ref2) {
     var id = _ref2.id,
-        title = _ref2.title;
-    setPath([].concat(_toConsumableArray(path), [{
-      id: id,
-      title: title
-    }]));
+        title = _ref2.title,
+        parent = _ref2.parent;
+
+    // if multi select
+    if (multi) {
+      // if top level reset the path
+      if (!parent) {
+        setPath([{
+          id: id,
+          title: title
+        }]);
+      } else {
+        var pathIds = path.map(function (p) {
+          return p.id;
+        }); // if item is already selected somewhere go back to that item
+
+        if (pathIds.includes(id)) {
+          var pathIdx = pathIds.findIndex(function (pathId) {
+            return pathId === id;
+          });
+
+          var newPath = _toConsumableArray(path).splice(0, pathIdx + 1);
+
+          setPath(_toConsumableArray(newPath));
+        } else {
+          // if the item is on the same level as another selected item start from the parent level
+          if (path.find(function (p) {
+            return p.parent === parent;
+          })) {
+            var parentIdx = path.findIndex(function (p) {
+              return p.id === parent;
+            });
+
+            var _newPath = _toConsumableArray(path).splice(0, parentIdx + 1);
+
+            setPath([].concat(_toConsumableArray(_newPath), [{
+              id: id,
+              title: title,
+              parent: parent
+            }]));
+          } else {
+            setPath([].concat(_toConsumableArray(path), [{
+              id: id,
+              title: title,
+              parent: parent
+            }]));
+          }
+        }
+      }
+    } else {
+      setPath([].concat(_toConsumableArray(path), [{
+        id: id,
+        title: title
+      }]));
+    }
   };
 
   return /*#__PURE__*/React.createElement("div", {
@@ -55,15 +106,22 @@ export var AddSelectList = function AddSelectList(_ref) {
     className: "".concat(blockClass)
   }, /*#__PURE__*/React.createElement(StructuredListBody, null, filteredItems.map(function (item) {
     return /*#__PURE__*/React.createElement(StructuredListRow, {
-      key: item.id
-    }, /*#__PURE__*/React.createElement(StructuredListCell, null, /*#__PURE__*/React.createElement("div", {
+      key: item.id,
+      className: "".concat(blockClass, "-row")
+    }, /*#__PURE__*/React.createElement(StructuredListCell, {
+      className: "".concat(blockClass, "-cell")
+    }, /*#__PURE__*/React.createElement("div", {
       className: "".concat(blockClass, "-cell-wrapper")
     }, multi ? /*#__PURE__*/React.createElement(Checkbox, {
       className: "".concat(blockClass, "-checkbox"),
       onChange: function onChange(value) {
         return handleMultiSelection(item.id, value);
       },
-      labelText: item.title,
+      labelText: !inColumn ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", {
+        className: "".concat(blockClass, "-cell-title")
+      }, item.title), /*#__PURE__*/React.createElement("span", {
+        className: "".concat(blockClass, "-cell-subtitle")
+      }, item.subtitle)) : item.title,
       id: item.id,
       checked: multiSelection.includes(item.id)
     }) : /*#__PURE__*/React.createElement(RadioButton, {
@@ -83,6 +141,7 @@ export var AddSelectList = function AddSelectList(_ref) {
 };
 AddSelectList.propTypes = {
   filteredItems: PropTypes.array,
+  inColumn: PropTypes.bool,
   multi: PropTypes.bool,
   multiSelection: PropTypes.array,
   path: PropTypes.array,

package/es/components/AddSelect/AddSelectSidebar.js

@@ -53,7 +53,13 @@ export var AddSelectSidebar = function AddSelectSidebar(_ref) {
         id = _ref2.id;
     return /*#__PURE__*/React.createElement("div", {
       className: "".concat(blockClass, "-accordion-title")
-    }, /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("p", null, title), /*#__PURE__*/React.createElement("p", null, subtitle)), /*#__PURE__*/React.createElement(Button, {
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "".concat(blockClass, "-selected-item")
+    }, /*#__PURE__*/React.createElement("p", {
+      className: "".concat(blockClass, "-selected-item-title")
+    }, title), /*#__PURE__*/React.createElement("p", {
+      className: "".concat(blockClass, "-selected-item-subtitle")
+    }, subtitle)), /*#__PURE__*/React.createElement(Button, {
       renderIcon: SubtractAlt32,
       iconDescription: removeIconDescription,
       hasIconOnly: true,

package/es/components/DataSpreadsheet/DataSpreadsheet.js

@@ -66,6 +66,21 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
       activeCellCoordinates = _useState4[0],
       setActiveCellCoordinates = _useState4[1];
 
+  var _useState5 = useState([]),
+      _useState6 = _slicedToArray(_useState5, 2),
+      selectionAreas = _useState6[0],
+      setSelectionAreas = _useState6[1];
+
+  var _useState7 = useState(false),
+      _useState8 = _slicedToArray(_useState7, 2),
+      clickAndHoldActive = _useState8[0],
+      setClickAndHoldActive = _useState8[1];
+
+  var _useState9 = useState(null),
+      _useState10 = _slicedToArray(_useState9, 2),
+      currentMatcher = _useState10[0],
+      setCurrentMatcher = _useState10[1];
+
   var cellSizeValue = getCellSize(cellSize);
   var defaultColumn = useMemo(function () {
     return {
@@ -108,6 +123,13 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
     if (activeCellHighlight) {
       activeCellHighlight.remove();
     }
+  }, [spreadsheetRef]); // Removes the cell selection elements
+
+  var removeCellSelections = useCallback(function () {
+    var cellSelections = spreadsheetRef.current.querySelectorAll(".".concat(blockClass, "__selection-area--element"));
+    Array.from(cellSelections).forEach(function (element) {
+      return element.remove();
+    });
   }, [spreadsheetRef]); // Click outside useEffect
 
   useEffect(function () {
@@ -116,7 +138,9 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
         return;
       }
 
+      setSelectionAreas([]);
       removeActiveCell();
+      removeCellSelections();
       setContainerHasFocus(false);
       setActiveCellCoordinates(null);
     };
@@ -125,7 +149,7 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
     return function () {
       document.removeEventListener('click', handleOutsideClick);
     };
-  }, [spreadsheetRef, removeActiveCell]);
+  }, [spreadsheetRef, removeActiveCell, removeCellSelections]);
   var createActiveCell = useCallback(function (_ref2) {
     var placementElement = _ref2.placementElement,
         coords = _ref2.coords,
@@ -172,12 +196,21 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
 
     if ([35, 36, 37, 38, 39, 40].indexOf(keyCode) > -1) {
       event.preventDefault();
+    } // Clear out all cell selection areas if user uses any arrow key
+
+
+    if ([37, 38, 39, 40].indexOf(keyCode) > -1) {
+      if (selectionAreas !== null && selectionAreas !== void 0 && selectionAreas.length) {
+        setSelectionAreas([]);
+        removeCellSelections();
+      }
     }
 
     switch (keyCode) {
       // Tab
       case 9:
         {
+          setSelectionAreas([]);
           removeActiveCell();
           setContainerHasFocus(false);
           setActiveCellCoordinates(null);
@@ -321,7 +354,7 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
           break;
         }
     }
-  }, [handleInitialArrowPress, activeCellCoordinates, removeActiveCell, columns.length, rows.length]); // Adds active cell highlight to correct cell onKeyDown
+  }, [handleInitialArrowPress, activeCellCoordinates, selectionAreas === null || selectionAreas === void 0 ? void 0 : selectionAreas.length, removeCellSelections, removeActiveCell, columns.length, rows.length]); // Adds active cell highlight to correct cell onKeyDown
 
   useEffect(function () {
     var activeCellPlacementElement = spreadsheetRef === null || spreadsheetRef === void 0 ? void 0 : spreadsheetRef.current.querySelector("[data-row-index=\"".concat(activeCellCoordinates === null || activeCellCoordinates === void 0 ? void 0 : activeCellCoordinates.row, "\"][data-column-index=\"").concat(activeCellCoordinates === null || activeCellCoordinates === void 0 ? void 0 : activeCellCoordinates.column, "\"]"));
@@ -354,6 +387,13 @@ export var DataSpreadsheet = /*#__PURE__*/React.forwardRef(function (_ref, ref)
     defaultColumn: defaultColumn,
     headerGroups: headerGroups
   }), /*#__PURE__*/React.createElement(DataSpreadsheetBody, {
+    clickAndHoldActive: clickAndHoldActive,
+    setClickAndHoldActive: setClickAndHoldActive,
+    currentMatcher: currentMatcher,
+    setCurrentMatcher: setCurrentMatcher,
+    setContainerHasFocus: setContainerHasFocus,
+    selectionAreas: selectionAreas,
+    setSelectionAreas: setSelectionAreas,
     cellSize: cellSize,
     defaultColumn: defaultColumn,
     getTableBodyProps: getTableBodyProps,

package/es/components/DataSpreadsheet/DataSpreadsheetBody.js

@@ -1,4 +1,5 @@
 import _extends from "@babel/runtime/helpers/extends";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 
 /**
  * Copyright IBM Corp. 2022, 2022
@@ -11,6 +12,9 @@ import PropTypes from 'prop-types';
 import { FixedSizeList } from 'react-window';
 import cx from 'classnames';
 import { pkg } from '../../settings';
+import { deepCloneObject } from '../../global/js/utils/deepCloneObject';
+import uuidv4 from '../../global/js/utils/uuidv4';
+import { createCellSelectionArea } from './createCellSelectionArea';
 var blockClass = "".concat(pkg.prefix, "--data-spreadsheet");
 export var DataSpreadsheetBody = function DataSpreadsheetBody(_ref) {
   var defaultColumn = _ref.defaultColumn,
@@ -19,10 +23,95 @@ export var DataSpreadsheetBody = function DataSpreadsheetBody(_ref) {
       prepareRow = _ref.prepareRow,
       rows = _ref.rows,
       setActiveCellCoordinates = _ref.setActiveCellCoordinates,
+      selectionAreas = _ref.selectionAreas,
+      setContainerHasFocus = _ref.setContainerHasFocus,
+      setSelectionAreas = _ref.setSelectionAreas,
       scrollBarSize = _ref.scrollBarSize,
-      totalColumnsWidth = _ref.totalColumnsWidth;
-  // Make sure that if the cellSize prop changes, the active
+      totalColumnsWidth = _ref.totalColumnsWidth,
+      clickAndHoldActive = _ref.clickAndHoldActive,
+      setClickAndHoldActive = _ref.setClickAndHoldActive,
+      currentMatcher = _ref.currentMatcher,
+      setCurrentMatcher = _ref.setCurrentMatcher;
+  // Create cell selection areas based on selectionAreas array
+  useEffect(function () {
+    if (selectionAreas && selectionAreas.length) {
+      selectionAreas.map(function (area) {
+        if (!area.areaCreated && area.point1 && area.point2 && area.matcher) {
+          // Do not create a cell selection area if point1 and point2 have the same values
+          // Cell selections must have two distinctly different points for an area to be created
+          if (area.point1.row === area.point2.row && area.point1.column === area.point2.column) {
+            var selectionAreasClone = deepCloneObject(selectionAreas);
+            var indexOfCurrentArea = selectionAreasClone.findIndex(function (item) {
+              return item.matcher === area.matcher;
+            });
+            selectionAreasClone[indexOfCurrentArea].areaCreated = false;
+            selectionAreasClone[indexOfCurrentArea].point2 = null;
+            return setSelectionAreas(selectionAreasClone);
+          }
+
+          createCellSelectionArea({
+            area: area,
+            blockClass: blockClass,
+            selectionAreas: selectionAreas,
+            setSelectionAreas: setSelectionAreas
+          });
+        }
+
+        return;
+      });
+    }
+  }, [selectionAreas, setSelectionAreas]); // Mouse up
+
+  useEffect(function () {
+    var handleMouseUp = function handleMouseUp(event) {
+      setClickAndHoldActive(false);
+      var cellButton = event.target.closest(".".concat(blockClass, "__body--td"));
+
+      if (cellButton) {
+        var endCellCoordinates = {
+          row: Number(cellButton.getAttribute('data-row-index')),
+          column: Number(cellButton.getAttribute('data-column-index'))
+        };
+        setCurrentMatcher(null);
+        setSelectionAreas(function (prev) {
+          var selectionAreaClone = deepCloneObject(prev);
+          var indexOfItemToUpdate = selectionAreaClone.findIndex(function (item) {
+            return item.matcher === currentMatcher;
+          }); // No items in the array have an object that matches the value of currentMatcher
+
+          if (indexOfItemToUpdate === -1) {
+            return prev;
+          }
+
+          selectionAreaClone[indexOfItemToUpdate].point2 = endCellCoordinates;
+          selectionAreaClone[indexOfItemToUpdate].areaCreated = false;
+          return selectionAreaClone;
+        });
+      } else {
+        var selectionAreaClone = deepCloneObject(selectionAreas);
+        var indexOfItemToUpdate = selectionAreaClone.findIndex(function (item) {
+          return item.matcher === currentMatcher;
+        });
+
+        if (indexOfItemToUpdate === -1) {
+          return;
+        }
+
+        var newArray = selectionAreaClone.filter(function (item) {
+          return item.matcher !== currentMatcher;
+        });
+        setCurrentMatcher(null);
+        setSelectionAreas(newArray);
+      }
+    };
+
+    document.addEventListener('mouseup', handleMouseUp);
+    return function () {
+      document.removeEventListener('mouseup', handleMouseUp);
+    };
+  }, [selectionAreas, currentMatcher, setSelectionAreas, setClickAndHoldActive, setCurrentMatcher]); // Make sure that if the cellSize prop changes, the active
   // cell also gets updated with the new size
+
   useEffect(function () {
     var listContainer = spreadsheetBodyRef === null || spreadsheetBodyRef === void 0 ? void 0 : spreadsheetBodyRef.current;
     var activeCellButton = listContainer.querySelector(".".concat(blockClass, "__active-cell--highlight"));
@@ -33,12 +122,68 @@ export var DataSpreadsheetBody = function DataSpreadsheetBody(_ref) {
   }, [defaultColumn === null || defaultColumn === void 0 ? void 0 : defaultColumn.rowHeight]); // onClick fn for each cell in the data spreadsheet body,
   // adds the active cell highlight
 
-  var handleBodyCellClick = useCallback(function (cell, columnIndex) {
-    setActiveCellCoordinates({
+  var handleBodyCellClick = useCallback(function (event, cell, columnIndex) {
+    var isHoldingCommandKey = event.metaKey || event.ctrlKey;
+    setContainerHasFocus(true);
+    var activeCoordinates = {
       row: cell.row.index,
       column: columnIndex
-    });
-  }, [setActiveCellCoordinates]); // Renders each cell in the spreadsheet body
+    };
+    var tempMatcher = uuidv4();
+    setActiveCellCoordinates(activeCoordinates); // prevent multiple selections unless cmd key is held
+    // meaning that selectionAreas should only have one item by default
+
+    if (isHoldingCommandKey) {
+      setSelectionAreas(function (prev) {
+        return [].concat(_toConsumableArray(prev), [{
+          point1: activeCoordinates,
+          matcher: tempMatcher
+        }]);
+      });
+    } else {
+      // remove all previous cell selections
+      var cellSelections = spreadsheetBodyRef.current.querySelectorAll(".".concat(blockClass, "__selection-area--element"));
+      Array.from(cellSelections).forEach(function (element) {
+        return element.remove();
+      });
+      setSelectionAreas([{
+        point1: activeCoordinates,
+        matcher: tempMatcher
+      }]);
+    }
+
+    setCurrentMatcher(tempMatcher);
+    setClickAndHoldActive(true);
+  }, [setActiveCellCoordinates, setSelectionAreas, setContainerHasFocus, setClickAndHoldActive, setCurrentMatcher]);
+  var handleBodyCellHover = useCallback(function (event, cell, columnIndex) {
+    if (clickAndHoldActive) {
+      var cellCoordinates = {
+        row: cell.row.index,
+        column: columnIndex
+      };
+      setSelectionAreas(function (prev) {
+        var _selectionAreaClone$i, _selectionAreaClone$i2;
+
+        var selectionAreaClone = deepCloneObject(prev);
+        var indexOfItemToUpdate = selectionAreaClone.findIndex(function (item) {
+          return item.matcher === currentMatcher;
+        }); // No items in the array match up with the currentMatcher value
+
+        if (indexOfItemToUpdate === -1) {
+          return prev;
+        } // Do not update state if you're still hovering on the same cell
+
+
+        if (((_selectionAreaClone$i = selectionAreaClone[indexOfItemToUpdate].point2) === null || _selectionAreaClone$i === void 0 ? void 0 : _selectionAreaClone$i.row) === cellCoordinates.row && ((_selectionAreaClone$i2 = selectionAreaClone[indexOfItemToUpdate].point2) === null || _selectionAreaClone$i2 === void 0 ? void 0 : _selectionAreaClone$i2.column) === cellCoordinates.column) {
+          return prev;
+        }
+
+        selectionAreaClone[indexOfItemToUpdate].point2 = cellCoordinates;
+        selectionAreaClone[indexOfItemToUpdate].areaCreated = false;
+        return selectionAreaClone;
+      });
+    }
+  }, [clickAndHoldActive, currentMatcher, setSelectionAreas]); // Renders each cell in the spreadsheet body
 
   var RenderRow = useCallback(function (_ref2) {
     var index = _ref2.index,
@@ -65,15 +210,19 @@ export var DataSpreadsheetBody = function DataSpreadsheetBody(_ref) {
         "data-row-index": cell.row.index,
         "data-column-index": index
       }, cell.getCellProps(), {
-        className: cx("".concat(blockClass, "__td"), "".concat(blockClass, "--interactive-cell-element")),
+        className: cx("".concat(blockClass, "__td"), "".concat(blockClass, "__body--td"), "".concat(blockClass, "--interactive-cell-element")),
         key: "cell_".concat(index),
-        onClick: function onClick() {
-          return handleBodyCellClick(cell, index);
+        onMouseDown: function onMouseDown(event) {
+          return handleBodyCellClick(event, cell, index);
         },
+        onMouseOver: function onMouseOver(event) {
+          return handleBodyCellHover(event, cell, index);
+        },
+        onFocus: function onFocus() {},
         type: "button"
       }), cell.render('Cell'));
     }));
-  }, [prepareRow, rows, defaultColumn.rowHeaderWidth, handleBodyCellClick]);
+  }, [prepareRow, rows, defaultColumn.rowHeaderWidth, handleBodyCellClick, handleBodyCellHover]);
   var spreadsheetBodyRef = useRef();
   return /*#__PURE__*/React.createElement("div", _extends({
     ref: spreadsheetBodyRef,
@@ -87,6 +236,16 @@ export var DataSpreadsheetBody = function DataSpreadsheetBody(_ref) {
   }, RenderRow));
 };
 DataSpreadsheetBody.propTypes = {
+  /**
+   * Is the user clicking and holding in the data spreadsheet body
+   */
+  clickAndHoldActive: PropTypes.bool,
+
+  /**
+   * This represents the id of the current cell selection area
+   */
+  currentMatcher: PropTypes.string,
+
   /**
    * Default spreadsheet sizing values
    */
@@ -126,11 +285,36 @@ DataSpreadsheetBody.propTypes = {
    */
   scrollBarSize: PropTypes.number,
 
+  /**
+   * Array of selection areas
+   */
+  selectionAreas: PropTypes.array,
+
   /**
    * Setter fn for activeCellCoordinates state value
    */
   setActiveCellCoordinates: PropTypes.func,
 
+  /**
+   * Setter fn for clickAndHold state value
+   */
+  setClickAndHoldActive: PropTypes.func,
+
+  /**
+   * Setter fn for containerHasFocus state value
+   */
+  setContainerHasFocus: PropTypes.func,
+
+  /**
+   * Setter fn for currentMatcher state value
+   */
+  setCurrentMatcher: PropTypes.func,
+
+  /**
+   * Setter fn for selectionAreas state value
+   */
+  setSelectionAreas: PropTypes.func,
+
   /**
    * The total columns width
    */

package/es/components/DataSpreadsheet/createActiveCellFn.js

@@ -40,6 +40,6 @@ export var createActiveCellFn = function createActiveCellFn(_ref) {
   activeCellButton.focus();
 
   if (typeof (coords === null || coords === void 0 ? void 0 : coords.column) === 'number' && typeof (coords === null || coords === void 0 ? void 0 : coords.row) === 'number') {
-    onActiveCellChange(activeCellValue);
+    onActiveCellChange === null || onActiveCellChange === void 0 ? void 0 : onActiveCellChange(activeCellValue);
   }
 };

package/es/components/DataSpreadsheet/createCellSelectionArea.js

@@ -0,0 +1,45 @@
+/**
+ * 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 { px } from '@carbon/layout';
+import { deepCloneObject } from '../../global/js/utils/deepCloneObject';
+export var createCellSelectionArea = function createCellSelectionArea(_ref) {
+  var area = _ref.area,
+      blockClass = _ref.blockClass,
+      selectionAreas = _ref.selectionAreas,
+      setSelectionAreas = _ref.setSelectionAreas;
+  var greatestRow = Math.max(area.point1.row, area.point2.row);
+  var greatestColumn = Math.max(area.point1.column, area.point2.column);
+  var lowestRowIndex = Math.min(area.point1.row, area.point2.row);
+  var lowestColumnIndex = Math.min(area.point1.column, area.point2.column);
+  var point1Element = document.querySelector("[data-row-index=\"".concat(area.point1.row, "\"][data-column-index=\"").concat(area.point1.column, "\"]"));
+  var selectionAreaCellWidth = point1Element.offsetWidth;
+  var selectionAreaCellHeight = point1Element.offsetHeight;
+  var selectionAreaTotalWidth = selectionAreaCellWidth * (greatestColumn - lowestColumnIndex + 1);
+  var selectionAreaTotalHeight = selectionAreaCellHeight * (greatestRow - lowestRowIndex + 1);
+  var bodyContainer = document.querySelector(".".concat(blockClass, "__list--container")).firstElementChild;
+  var placementElement = bodyContainer.querySelector("[data-row-index=\"".concat(lowestRowIndex, "\"][data-column-index=\"").concat(lowestColumnIndex, "\"]"));
+  var relativePosition = {
+    top: placementElement.getBoundingClientRect().top - bodyContainer.getBoundingClientRect().top,
+    left: placementElement.getBoundingClientRect().left - bodyContainer.getBoundingClientRect().left
+  };
+  var selectionAreaElement = document.querySelector("[data-matcher-id=\"".concat(area.matcher, "\"]")) || document.createElement('div');
+  selectionAreaElement.classList.add("".concat(blockClass, "__selection-area--element"));
+  selectionAreaElement.setAttribute('data-matcher-id', area.matcher);
+  selectionAreaElement.style.width = px(selectionAreaTotalWidth);
+  selectionAreaElement.style.height = px(selectionAreaTotalHeight);
+  selectionAreaElement.style.left = px(relativePosition.left);
+  selectionAreaElement.style.top = px(relativePosition.top);
+  bodyContainer.appendChild(selectionAreaElement);
+  var selectionAreasClone = deepCloneObject(selectionAreas);
+  var indexOfCurrentArea = selectionAreasClone.findIndex(function (item) {
+    return item.matcher === area.matcher;
+  }); // We need to add another property to the selectionAreas object array to
+  // let us know if an area has been created for each item already, ie createdArea: true
+
+  selectionAreasClone[indexOfCurrentArea].areaCreated = true;
+  setSelectionAreas(selectionAreasClone);
+};

package/es/components/InlineEdit/InlineEdit.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 = ["cancelDescription", "className", "disabled", "editDescription", "editVisibleOnHoverOnly", "id", "invalid", "invalidText", "labelText", "light", "onCancel", "onSave", "onChange", "placeholder", "saveDescription", "size", "value", "warn", "warnText"];
+var _excluded = ["cancelDescription", "className", "disabled", "editAlwaysVisible", "editDescription", "id", "invalid", "invalidText", "labelText", "light", "onCancel", "onSave", "onChange", "placeholder", "saveDescription", "size", "value", "warn", "warnText"];
 
 /**
  * Copyright IBM Corp. 2022, 2022
@@ -41,8 +41,8 @@ export var InlineEdit = /*#__PURE__*/React.forwardRef(function (_ref, refIn) {
   var cancelDescription = _ref.cancelDescription,
       className = _ref.className,
       disabled = _ref.disabled,
+      editAlwaysVisible = _ref.editAlwaysVisible,
       editDescription = _ref.editDescription,
-      editVisibleOnHoverOnly = _ref.editVisibleOnHoverOnly,
       id = _ref.id,
       invalid = _ref.invalid,
       invalidText = _ref.invalidText,
@@ -89,6 +89,7 @@ export var InlineEdit = /*#__PURE__*/React.forwardRef(function (_ref, refIn) {
   };
 
   var handleEdit = function handleEdit(ev) {
+    /* istanbul ignore else */
     if (!disabled) {
       var rightOfInput = ev.currentTarget.classList.contains("".concat(blockClass, "__edit")) || ev.target.classList.contains("".concat(blockClass, "__after-input-elements"));
       var leftOfInput = ev.currentTarget = ev.target.classList.contains("".concat(blockClass)); // clicking on the content editable element should not set either of these to true
@@ -135,9 +136,12 @@ export var InlineEdit = /*#__PURE__*/React.forwardRef(function (_ref, refIn) {
     if (onChange) {
       onChange(refInput.current.innerText);
     }
-  };
+  }; // pasting into contentEditable not supported by userEvent
+
 
-  var handlePaste = function handlePaste(ev) {
+  var handlePaste =
+  /* istanbul ignore next */
+  function handlePaste(ev) {
     ev.preventDefault(); // Get clipboard as plain text
 
     var text = (ev.clipboardData || window.clipboardData).getData('text/plain'); // remove \n
@@ -182,9 +186,16 @@ export var InlineEdit = /*#__PURE__*/React.forwardRef(function (_ref, refIn) {
   };
 
   var handleKeyDown = function handleKeyDown(ev) {
-    if (ev.key === 'Enter') {
-      ev.preventDefault();
-      refInput.current.blur(); // will cause save
+    switch (ev.key) {
+      case 'Enter':
+        ev.preventDefault();
+        refInput.current.blur(); // will cause save
+
+        break;
+
+      case 'Escape':
+        handleCancel();
+        break;
     }
   };
   /*
@@ -266,7 +277,7 @@ export var InlineEdit = /*#__PURE__*/React.forwardRef(function (_ref, refIn) {
       disabled: value === internalValue
     })) : /*#__PURE__*/React.createElement(Button, {
       "aria-hidden": "true",
-      className: cx("".concat(blockClass, "__edit"), _defineProperty({}, "".concat(blockClass, "__edit--hover-visible"), editVisibleOnHoverOnly)),
+      className: cx("".concat(blockClass, "__edit"), _defineProperty({}, "".concat(blockClass, "__edit--always-visible"), editAlwaysVisible)),
       kind: "ghost",
       hasIconOnly: true,
       iconDescription: editDescription,
@@ -306,15 +317,14 @@ InlineEdit.propTypes = {
   disabled: PropTypes.bool,
 
   /**
-   * Label for the edit button
+   * By default the edit icon is shown on hover only.
    */
-  editDescription: PropTypes.string.isRequired,
+  editAlwaysVisible: PropTypes.bool,
 
   /**
-   * In some scenarios the edit icon only needs to be shown on hover. These cases are where continual visibility of
-   * the edit icon is redundant. E.g. a spreadsheet a property panel.
+   * Label for the edit button
    */
-  editVisibleOnHoverOnly: PropTypes.bool,
+  editDescription: PropTypes.string.isRequired,
 
   /**
    * ID for inline edit