@carbon/ibm-products 1.32.1 → 1.34.0

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

@@ -24,7 +24,7 @@ import { usePreviousValue } from '../../../../../../global/js/hooks';
 import { prepareProps } from '../../../../../../global/js/utils/props-helper';
 var blockClass = "".concat(pkg.prefix, "--datagrid");
 export var InlineEditCell = function InlineEditCell(_ref) {
-  var _cx3;
+  var _config$validator, _cx3;
 
   var cell = _ref.cell,
       config = _ref.config,
@@ -89,7 +89,24 @@ export var InlineEditCell = function InlineEditCell(_ref) {
       return item.id === columnId;
     });
     setCellLabel(typeof columnLabel.Header === 'string' ? columnLabel.Header : 'Inline edit cell label'); // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []); // If you are in edit mode and click outside of the cell,
+  }, []); // Reverts cellValue back to initialValue when exiting edit mode via clicking outside
+  // of the cell (either on a regular cell or clicking into another inline edit cell) and the
+  // edit input is in an invalid state
+
+  useEffect(function () {
+    if ((previousState === null || previousState === void 0 ? void 0 : previousState.editId) === cellId && !editId || (previousState === null || previousState === void 0 ? void 0 : previousState.editId) === cellId && cellId !== editId) {
+      var _ref3 = config || {},
+          validator = _ref3.validator;
+
+      var isInvalid = validator === null || validator === void 0 ? void 0 : validator(cellValue);
+
+      if (isInvalid) {
+        setCellValue(initialValue);
+        saveCellData(initialValue);
+        return;
+      }
+    }
+  }, [previousState === null || previousState === void 0 ? void 0 : previousState.editId, editId, cellId, cellValue, config, initialValue, saveCellData]); // If you are in edit mode and click outside of the cell,
   // this changes the cell back to the InlineEditButton
 
   useEffect(function () {
@@ -201,6 +218,16 @@ export var InlineEditCell = function InlineEditCell(_ref) {
               return;
             }
 
+            var _ref4 = config || {},
+                validator = _ref4.validator;
+
+            var isInvalid = validator === null || validator === void 0 ? void 0 : validator(cellValue); // If an invalid state is detected, Tab/Enter should not do anything
+            // until the input has a valid state once again
+
+            if (isInvalid) {
+              return;
+            }
+
             var newCellId = getNewCellId(key);
             saveCellData(cellValue);
             setInitialValue(cellValue);
@@ -251,8 +278,8 @@ export var InlineEditCell = function InlineEditCell(_ref) {
   };
 
   var renderSelectCell = function renderSelectCell() {
-    var _ref3 = config || {},
-        inputProps = _ref3.inputProps;
+    var _ref5 = config || {},
+        inputProps = _ref5.inputProps;
 
     return /*#__PURE__*/React.createElement(Dropdown, _extends({
       id: cellId,
@@ -288,8 +315,8 @@ export var InlineEditCell = function InlineEditCell(_ref) {
       },
       downshiftProps: {
         onStateChange: function onStateChange(downshiftState) {
-          var _ref4 = downshiftState || {},
-              isOpen = _ref4.isOpen; // !isOpen does not work in this case because a state change occurs on hover of the
+          var _ref6 = downshiftState || {},
+              isOpen = _ref6.isOpen; // !isOpen does not work in this case because a state change occurs on hover of the
           // menu items and isOpen is changed to undefined which causes dispatch to be called unexpectedly
 
 
@@ -390,6 +417,55 @@ export var InlineEditCell = function InlineEditCell(_ref) {
     return null;
   };
 
+  var renderNumberInput = function renderNumberInput() {
+    var _ref7 = config || {},
+        validator = _ref7.validator;
+
+    return /*#__PURE__*/React.createElement(NumberInput, _extends({
+      placeholder: placeholder,
+      label: cellLabel
+    }, inputProps, {
+      id: cellId,
+      hideLabel: true,
+      defaultValue: cellValue,
+      invalid: validator === null || validator === void 0 ? void 0 : validator(cellValue),
+      invalidText: (inputProps === null || inputProps === void 0 ? void 0 : inputProps.invalidText) || 'Provide missing invalidText',
+      onChange: function onChange(event) {
+        setCellValue(event.imaginaryTarget.value);
+
+        if (inputProps.onChange) {
+          inputProps.onChange(event.imaginaryTarget.value);
+        }
+      },
+      ref: numberInputRef
+    }));
+  };
+
+  var renderTextInput = function renderTextInput() {
+    var _ref8 = config || {},
+        validator = _ref8.validator;
+
+    var isInvalid = validator === null || validator === void 0 ? void 0 : validator(cellValue);
+    return /*#__PURE__*/React.createElement(TextInput, _extends({
+      labelText: cellLabel,
+      placeholder: placeholder
+    }, inputProps, {
+      id: cellId,
+      hideLabel: true,
+      defaultValue: cellValue,
+      invalid: isInvalid,
+      invalidText: (inputProps === null || inputProps === void 0 ? void 0 : inputProps.invalidText) || 'Provide missing invalidText',
+      onChange: function onChange(event) {
+        setCellValue(event.target.value);
+
+        if (inputProps.onChange) {
+          inputProps.onChange(event.target.value);
+        }
+      },
+      ref: textInputRef
+    }));
+  };
+
   return (
     /*#__PURE__*/
     // eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions
@@ -402,7 +478,7 @@ export var InlineEditCell = function InlineEditCell(_ref) {
       "data-inline-type": type,
       onClick: !nonEditCell ? handleInlineCellClick : addActiveState,
       onKeyDown: !nonEditCell ? handleKeyDown : null,
-      className: cx("".concat(blockClass, "__inline-edit--outer-cell-button"), (_cx3 = {}, _defineProperty(_cx3, "".concat(blockClass, "__inline-edit--outer-cell-button--").concat(rowSize), rowSize), _defineProperty(_cx3, "".concat(blockClass, "__inline-edit--outer-cell-button--lg"), !rowSize), _cx3))
+      className: cx("".concat(blockClass, "__inline-edit--outer-cell-button"), (_cx3 = {}, _defineProperty(_cx3, "".concat(blockClass, "__inline-edit--outer-cell-button--").concat(rowSize), rowSize), _defineProperty(_cx3, "".concat(blockClass, "__inline-edit--outer-cell-button--lg"), !rowSize), _defineProperty(_cx3, "".concat(blockClass, "__inline-edit--outer-cell-button--invalid"), config === null || config === void 0 ? void 0 : (_config$validator = config.validator) === null || _config$validator === void 0 ? void 0 : _config$validator.call(config, cellValue)), _cx3))
     }, !inEditMode && /*#__PURE__*/React.createElement(InlineEditButton, {
       isActiveCell: cellId === activeCellId,
       renderIcon: setRenderIcon(),
@@ -415,37 +491,7 @@ export var InlineEditCell = function InlineEditCell(_ref) {
       totalInlineEditColumns: totalInlineEditColumns,
       totalColumns: totalColumns,
       type: type
-    }), !nonEditCell && inEditMode && cellId === activeCellId && /*#__PURE__*/React.createElement(React.Fragment, null, type === 'text' && /*#__PURE__*/React.createElement(TextInput, _extends({
-      labelText: cellLabel,
-      placeholder: placeholder
-    }, inputProps, {
-      id: cellId,
-      hideLabel: true,
-      defaultValue: cellValue,
-      onChange: function onChange(event) {
-        setCellValue(event.target.value);
-
-        if (inputProps.onChange) {
-          inputProps.onChange(event.target.value);
-        }
-      },
-      ref: textInputRef
-    })), type === 'number' && /*#__PURE__*/React.createElement(NumberInput, _extends({
-      placeholder: placeholder,
-      label: cellLabel
-    }, inputProps, {
-      id: cellId,
-      hideLabel: true,
-      defaultValue: cellValue,
-      onChange: function onChange(event) {
-        setCellValue(event.imaginaryTarget.value);
-
-        if (inputProps.onChange) {
-          inputProps.onChange(event.imaginaryTarget.value);
-        }
-      },
-      ref: numberInputRef
-    })), type === 'selection' && renderSelectCell(), type === 'date' && renderDateCell()))
+    }), !nonEditCell && inEditMode && cellId === activeCellId && /*#__PURE__*/React.createElement(React.Fragment, null, type === 'text' && renderTextInput(), type === 'number' && renderNumberInput(), type === 'selection' && renderSelectCell(), type === 'date' && renderDateCell()))
   );
 };
 InlineEditCell.propTypes = {

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

@@ -35,11 +35,11 @@ export var handleGridKeyPress = function handleGridKeyPress(_ref) {
         type: 'EXIT_EDIT_MODE',
         payload: activeCellId
       });
+      var inlineEditArea = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit"));
+      inlineEditArea.focus();
     }
 
     event.preventDefault();
-    var inlineEditArea = document.querySelector("#".concat(instance.tableId, " .").concat(blockClass, "__table-with-inline-edit"));
-    inlineEditArea.focus();
     return;
   }
 

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

@@ -6,6 +6,7 @@
  */
 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,
@@ -62,5 +63,25 @@ export var handleMultipleKeys = function handleMultipleKeys(_ref) {
         });
       }, 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/utils/getArgTypes.js

@@ -81,5 +81,9 @@ export var ARG_TYPES = {
       type: 'number'
     },
     description: 'This value controls the height of the expanded content area. _This value is set/passed inside of the `datagridState` object._'
+  },
+  customizeColumnsProps: {
+    control: 'object',
+    description: 'This is an object containing all of the props used with the column customization extension. _This value is set/passed inside of the `datagridState` object._'
   }
 };

package/es/components/Datagrid/utils/getInlineEditColumns.js

@@ -31,25 +31,43 @@ export var getInlineEditColumns = function getInlineEditColumns() {
     accessor: 'firstName',
     inlineEdit: {
       type: 'text',
-      inputProps: {} // These props are passed to the Carbon component used for inline editing
-
+      // required for including validation, this is used to set the invalid prop internally
+      validator: function validator(n) {
+        return n.length >= 40;
+      },
+      // These props are passed to the Carbon component used for inline editing
+      inputProps: {
+        invalidText: 'Invalid text, character count must be less than 40'
+      }
     }
   }, {
     Header: 'Last Name',
     accessor: 'lastName',
     inlineEdit: {
       type: 'text',
-      inputProps: {} // These props are passed to the Carbon component used for inline editing
-
+      // required for including validation, this is used to set the invalid prop internally
+      validator: function validator(n) {
+        return n.length >= 40;
+      },
+      // These props are passed to the Carbon component used for inline editing
+      inputProps: {
+        invalidText: 'Invalid text, character count must be less than 40'
+      }
     }
   }, {
     Header: 'Age',
     accessor: 'age',
     width: 120,
     inlineEdit: {
+      // required for including validation, this is used to set the invalid prop internally
+      validator: function validator(n) {
+        return n && n < 18;
+      },
       type: 'number',
-      inputProps: {} // These props are passed to the Carbon component used for inline editing
-
+      // These props are passed to the Carbon component used for inline editing
+      inputProps: {
+        invalidText: 'Invalid number, must be 18 or greater'
+      }
     }
   }, {
     Header: 'Visits',
@@ -86,7 +104,7 @@ export var getInlineEditColumns = function getInlineEditColumns() {
         // These props are passed to the Carbon component used for inline editing
         items: inlineEditSelectItems,
         onChange: function onChange(item) {
-          return console.log(item);
+          console.log(item);
         }
       }
     }

package/es/components/Datagrid/utils/makeData.js

@@ -65,6 +65,14 @@ var renderStatusIcon = function renderStatusIcon(statusChance) {
   return /*#__PURE__*/React.createElement(StatusIcon, iconProps);
 };
 
+var renderDocLink = function renderDocLink(statusChance) {
+  var docLinkObj = {
+    href: statusChance > 0.66 ? 'http://carbondesignsystem.com/' : statusChance > 0.33 ? 'https://pages.github.ibm.com/cdai-design/pal/' : 'http://carbon-for-ibm-products.netlify.app/',
+    text: statusChance > 0.66 ? 'Carbon Design System' : statusChance > 0.33 ? 'Carbon for IBM Products PAL' : 'Carbon for IBM Products storybook'
+  };
+  return docLinkObj;
+};
+
 var newPerson = function newPerson() {
   var statusChance = Math.random();
   var initialChartTypeIndex = getRandomInteger(0, 2);
@@ -169,7 +177,8 @@ var newPerson = function newPerson() {
     chartType: initialChartTypeIndex === 0 ? inlineEditSelectItems[0] : initialChartTypeIndex === 1 ? inlineEditSelectItems[1] : inlineEditSelectItems[2],
     activeSince: statusChance > 0.66 ? activeSinceDate : statusChance > 0.33 ? yesterdayDate : twoDaysAgoDate,
     bonus: "$\r".concat(getRandomInteger(100, 500, 2)),
-    status_icon: renderStatusIcon(statusChance)
+    status_icon: renderStatusIcon(statusChance),
+    doc_link: renderDocLink(statusChance)
   };
 };
 

package/es/components/InlineEditV2/InlineEditV2.js

@@ -0,0 +1,249 @@
+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 = ["cancelLabel", "editLabel", "invalid", "invalidLabel", "onCancel", "onChange", "onSave", "readOnly", "saveLabel", "value"];
+import React, { useState, useEffect, forwardRef, useRef } from 'react';
+import { Button } from 'carbon-components-react';
+import cx from 'classnames';
+import PropTypes from 'prop-types';
+import { Edit24, Checkmark24, Close24, EditOff24, WarningFilled16 } from '@carbon/icons-react';
+import { pkg, carbon } from '../../settings';
+import { getDevtoolsProps } from '../../global/js/utils/devtools';
+var componentName = 'InlineEditV2';
+var blockClass = "".concat(pkg.prefix, "--inline-edit-v2");
+export var InlineEditV2 = /*#__PURE__*/forwardRef(function (_ref, ref) {
+  var _cx;
+
+  var cancelLabel = _ref.cancelLabel,
+      editLabel = _ref.editLabel,
+      invalid = _ref.invalid,
+      invalidLabel = _ref.invalidLabel,
+      onCancel = _ref.onCancel,
+      onChange = _ref.onChange,
+      onSave = _ref.onSave,
+      readOnly = _ref.readOnly,
+      saveLabel = _ref.saveLabel,
+      value = _ref.value,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      focused = _useState2[0],
+      setFocused = _useState2[1];
+
+  var _useState3 = useState(''),
+      _useState4 = _slicedToArray(_useState3, 2),
+      initialValue = _useState4[0],
+      setInitialValue = _useState4[1];
+
+  var _useState5 = useState(false),
+      _useState6 = _slicedToArray(_useState5, 2),
+      dirtyInput = _useState6[0],
+      setDirtyInput = _useState6[1];
+
+  var inputRef = useRef(null);
+  var canSave = value !== initialValue && !invalid;
+  var escaping = useRef(false);
+  useEffect(function () {
+    if (!initialValue && !dirtyInput) {
+      setInitialValue(value);
+    }
+  }, [initialValue, dirtyInput, value]);
+
+  var isTargetingChild = function isTargetingChild(_ref2) {
+    var currentTarget = _ref2.currentTarget,
+        relatedTarget = _ref2.relatedTarget;
+    return currentTarget.contains(relatedTarget);
+  };
+
+  var onChangeHandler = function onChangeHandler(_ref3) {
+    var target = _ref3.target;
+
+    if (!dirtyInput) {
+      setDirtyInput(true);
+    }
+
+    onChange(target.value);
+  };
+
+  var onFocusHandler = function onFocusHandler(e) {
+    if (readOnly) {
+      return;
+    }
+
+    if (!isTargetingChild(e)) {
+      inputRef.current.focus();
+      setFocused(true);
+    }
+  };
+
+  var onSaveHandler = function onSaveHandler() {
+    setInitialValue(value);
+    setFocused(false);
+    setDirtyInput(false);
+    onSave();
+  };
+
+  var onCancelHandler = function onCancelHandler() {
+    setFocused(false);
+    setDirtyInput(false);
+    onCancel(initialValue);
+  };
+
+  var onBlurHandler = function onBlurHandler(e) {
+    if (readOnly || escaping.current) {
+      return;
+    }
+
+    if (!isTargetingChild(e)) {
+      if (canSave) {
+        onSaveHandler();
+      } else {
+        onCancelHandler();
+      }
+    }
+  };
+
+  var returnHandler = function returnHandler() {
+    if (canSave) {
+      onSaveHandler();
+    }
+  };
+
+  var escapeHandler = function escapeHandler() {
+    onCancelHandler();
+  };
+
+  var onKeyHandler = function onKeyHandler(e) {
+    // to prevent blur handler from being called twice add additional state to check if escape is being used
+    escaping.current = true;
+
+    switch (e.key) {
+      case 'Escape':
+        inputRef.current.blur();
+        escapeHandler();
+        break;
+
+      case 'Enter':
+        inputRef.current.blur();
+        returnHandler();
+        break;
+
+      default:
+        break;
+    }
+
+    escaping.current = false;
+  };
+
+  return /*#__PURE__*/React.createElement("div", _extends({}, rest, {
+    ref: ref
+  }, getDevtoolsProps(componentName)), /*#__PURE__*/React.createElement("div", {
+    className: cx(blockClass, (_cx = {}, _defineProperty(_cx, "".concat(blockClass, "-focused"), focused), _defineProperty(_cx, "".concat(blockClass, "-readonly"), readOnly), _cx)),
+    onFocus: onFocusHandler,
+    onBlur: onBlurHandler
+  }, /*#__PURE__*/React.createElement("input", {
+    className: cx("".concat(blockClass, "__text-input"), "".concat(carbon.prefix, "--text-input")),
+    type: "text",
+    value: value,
+    onChange: onChangeHandler,
+    ref: inputRef,
+    readOnly: readOnly,
+    onKeyDown: onKeyHandler
+  }), focused ? /*#__PURE__*/React.createElement(React.Fragment, null, invalid && /*#__PURE__*/React.createElement(WarningFilled16, {
+    className: "".concat(blockClass, "__warning-icon")
+  }), /*#__PURE__*/React.createElement(Button, {
+    hasIconOnly: true,
+    renderIcon: Close24,
+    size: "sm",
+    iconDescription: cancelLabel,
+    onClick: onCancelHandler,
+    kind: "ghost",
+    tabIndex: 0,
+    key: "cancel",
+    className: "".concat(blockClass, "__btn ").concat(blockClass, "__btn-cancel")
+  }), canSave && /*#__PURE__*/React.createElement(Button, {
+    hasIconOnly: true,
+    renderIcon: Checkmark24,
+    size: "sm",
+    iconDescription: saveLabel,
+    onClick: onSaveHandler,
+    kind: "ghost",
+    tabIndex: 0,
+    key: "save",
+    className: "".concat(blockClass, "__btn ").concat(blockClass, "__btn-save"),
+    disabled: !canSave
+  })) : /*#__PURE__*/React.createElement(Button, {
+    className: "".concat(blockClass, "__btn ").concat(blockClass, "__btn-edit"),
+    hasIconOnly: true,
+    renderIcon: readOnly ? EditOff24 : Edit24,
+    size: "sm",
+    iconDescription: editLabel,
+    onClick: onFocusHandler,
+    kind: "ghost",
+    disabled: readOnly,
+    tabIndex: 0,
+    key: "edit"
+  })), focused && invalid && /*#__PURE__*/React.createElement("p", {
+    className: "".concat(blockClass, "__warning-text")
+  }, invalidLabel));
+});
+InlineEditV2 = pkg.checkComponentEnabled(InlineEditV2, componentName);
+InlineEditV2.displayName = componentName;
+InlineEditV2.propTypes = {
+  /**
+   * label for cancel button
+   */
+  cancelLabel: PropTypes.string.isRequired,
+
+  /**
+   * label for edit button
+   */
+  editLabel: PropTypes.string.isRequired,
+
+  /**
+   * determines if the input is invalid
+   */
+  invalid: PropTypes.bool,
+
+  /**
+   * text that is displayed if the input is invalid
+   */
+  invalidLabel: PropTypes.string,
+
+  /**
+   * handler that is called when the cancel button is pressed or when the user removes focus from the input and there is no new value
+   */
+  onCancel: PropTypes.func.isRequired,
+
+  /**
+   * handler that is called when the input is updated
+   */
+  onChange: PropTypes.func.isRequired,
+
+  /**
+   * handler that is called when the save button is pressed or when the user removes focus from the input if it has a new value
+   */
+  onSave: PropTypes.func.isRequired,
+
+  /**
+   * determines if the input is in readOnly mode
+   */
+  readOnly: PropTypes.bool,
+
+  /**
+   * label for save button
+   */
+  saveLabel: PropTypes.string.isRequired,
+
+  /**
+   * current value of the input
+   */
+  value: PropTypes.string.isRequired
+};
+InlineEditV2.defaultProps = {
+  invalid: false,
+  invalidLabel: '',
+  readOnly: false
+};

package/es/components/InlineEditV2/index.js

@@ -0,0 +1 @@
+export { InlineEditV2 } from './InlineEditV2';

package/es/components/PageHeader/PageHeaderTitle.js

@@ -68,7 +68,9 @@ export var PageHeaderTitle = function PageHeaderTitle(_ref) {
   return /*#__PURE__*/React.createElement("div", {
     className: cx("".concat(blockClass, "__title"), _defineProperty({}, "".concat(blockClass, "__title--editable"), isEditable), _defineProperty({}, "".concat(blockClass, "__title--fades"), hasBreadcrumbRow)),
     title: titleText
-  }, titleInnards);
+  }, /*#__PURE__*/React.createElement("h1", {
+    className: "".concat(blockClass, "__title-wrapper")
+  }, titleInnards));
 };
 export var inlineEditRequired = function inlineEditRequired(_ref2) {
   var onSave = _ref2.onSave;