@decisiv/ui-components 2.0.1-alpha.17 → 2.0.1-alpha.173

package/lib/components/Combobox/index.js

@@ -11,10 +11,18 @@ var _findIndex = _interopRequireDefault(require("lodash/findIndex"));
 
 var _get = _interopRequireDefault(require("lodash/get"));
 
+var _union = _interopRequireDefault(require("lodash/union"));
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
 var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
 
+var _last = _interopRequireDefault(require("lodash/last"));
+
 var _rem = _interopRequireDefault(require("polished/lib/helpers/rem"));
 
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
 var _react = _interopRequireWildcard(require("react"));
 
 var _breakpointObserver = require("@decisiv/breakpoint-observer");
@@ -25,6 +33,8 @@ var _Question = _interopRequireDefault(require("@decisiv/iconix/lib/components/Q
 
 var _composeReactRefs = _interopRequireDefault(require("@seznam/compose-react-refs"));
 
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
 var _InputField = _interopRequireDefault(require("../../atoms/InputField"));
 
 var _useClickOutside = _interopRequireDefault(require("../../utils/useClickOutside"));
@@ -49,12 +59,22 @@ var _schema = _interopRequireDefault(require("./schema"));
 
 var _utils = require("./utils");
 
+var _usePrevious = _interopRequireDefault(require("../../utils/usePrevious"));
+
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { keys.push.apply(keys, Object.getOwnPropertySymbols(object)); } if (enumerableOnly) keys = keys.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
@@ -71,6 +91,14 @@ function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d =
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
+var StyledInputDiv = _styledComponents.default.div.withConfig({
+  displayName: "Combobox__StyledInputDiv",
+  componentId: "zvfxxj-0"
+})(["position:relative;width:100%;max-width:", ";"], function (_ref) {
+  var maxWidth = _ref.maxWidth;
+  return maxWidth;
+});
+
 function Combobox(props, ref) {
   var clearButtonLabel = props.clearButtonLabel,
       defaultValue = props.defaultValue,
@@ -78,18 +106,24 @@ function Combobox(props, ref) {
       inputContainerRef = props.inputContainerRef,
       label = props.label,
       loading = props.loading,
+      _props$maxWidth = props.maxWidth,
+      maxWidth = _props$maxWidth === void 0 ? '100%' : _props$maxWidth,
+      multiple = props.multiple,
       name = props.name,
       onChangeValue = props.onChangeValue,
       onClick = props.onClick,
       onFocus = props.onFocus,
+      onHide = props.onHide,
       onKeyDown = props.onKeyDown,
+      onShow = props.onShow,
       _props$options = props.options,
       options = _props$options === void 0 ? [] : _props$options,
+      renderOptionLabel = props.renderOptionLabel,
       propValue = props.value,
       _props$variant = props.variant,
       variant = _props$variant === void 0 ? 'sync' : _props$variant,
-      renderOptionLabel = props.renderOptionLabel,
-      zIndex = props.zIndex;
+      zIndex = props.zIndex,
+      containerSelector = props.containerSelector;
 
   var _useCombobox = (0, _useCombobox2.default)(props),
       getInputFieldProps = _useCombobox.getInputFieldProps,
@@ -123,24 +157,77 @@ function Combobox(props, ref) {
   var _useState5 = (0, _react.useState)(false),
       _useState6 = _slicedToArray(_useState5, 2),
       isPopoverVisible = _useState6[0],
-      setIsPopoverVisible = _useState6[1];
+      setIsPopoverVisibleState = _useState6[1];
+
+  var previousIsPopoverVisible = (0, _usePrevious.default)(isPopoverVisible);
+  /**
+   * Combobox controls the Popover instead of relying on the Popover's internal state.
+   * The Popover's onShow/ onHide handlers only function when the Popover is _not_
+   * controlled. This effect watches for a toggled visibility state, and calls the appropriate
+   * event handler.
+   */
 
   (0, _react.useEffect)(function () {
-    // Set the "default" active ID to the first, if it exists.
-    if (!(0, _isEmpty.default)(options) && !activeId) {
-      setActiveId((0, _get.default)(options, '0.id'));
+    if (previousIsPopoverVisible && !isPopoverVisible && onHide) {
+      onHide();
+    }
+
+    if (!previousIsPopoverVisible && isPopoverVisible && onShow) {
+      onShow();
+    }
+  }, [isPopoverVisible, previousIsPopoverVisible, onShow, onHide]);
+  /**
+   * Update the dropdown list visibility.
+   */
+
+  var updateIsPopoverVisible = (0, _react.useCallback)(function (arg) {
+    if (arg === true || arg === false) setIsPopoverVisibleState(arg);
+    if (arg === 'toggle') setIsPopoverVisibleState(function (old) {
+      return !old;
+    });
+  }, [setIsPopoverVisibleState]);
+  /**
+   * This generates a flat list of the options (including those in categories)
+   * in the order they are presented in the dropdown list. Filtering disabled elements.
+   */
+
+  var flatOptions = (0, _react.useMemo)(function () {
+    return options.reduce(function (acc, curr) {
+      if ((0, _utils.isCategory)(curr)) {
+        var items = (0, _isArray.default)(curr.items) ? curr.items.filter(function (option) {
+          return !option.disabled;
+        }) : [];
+        return acc.concat(items);
+      }
+
+      if (!curr.disabled) {
+        return acc.concat(curr);
+      }
+
+      return acc;
+    }, []);
+  }, [options]);
+  (0, _react.useEffect)(function () {
+    // Set the "default" active ID to the first in flatOptions, if it exists.
+    if (!(0, _isEmpty.default)(flatOptions) && !activeId) {
+      setActiveId((0, _get.default)(flatOptions, '0.id'));
     } // For async comboboxes, if the input is focused, the dropdown should be open.
 
 
-    if (isFocused && variant === 'async') {
-      setIsPopoverVisible(true);
+    if (isFocused && variant === 'async' || multiple && internalInputValue !== '') {
+      updateIsPopoverVisible(true);
     }
-  }, [activeId, isFocused, options, variant]); // The selectedValue is the id of the selectedOption, or an empty string if none selected.
+  }, [activeId, isFocused, flatOptions, variant, multiple, internalInputValue, updateIsPopoverVisible]); // The selectedValue is the id of the selectedOption, or an empty string if none selected.
 
-  var _useState7 = (0, _react.useState)(propValue || defaultValue || undefined),
+  var _useState7 = (0, _react.useState)(!Array.isArray(propValue) && propValue || !Array.isArray(defaultValue) && defaultValue || undefined),
       _useState8 = _slicedToArray(_useState7, 2),
       selectedValue = _useState8[0],
       setSelectedValue = _useState8[1];
+
+  var _useState9 = (0, _react.useState)(Array.isArray(propValue) && propValue || undefined),
+      _useState10 = _slicedToArray(_useState9, 2),
+      selectedValues = _useState10[0],
+      setSelectedValues = _useState10[1];
   /**
    * The current selected value and current input value are saved independently,
    * but must be kept in sync. Using a single callback for this keeps it simple(r).
@@ -149,13 +236,51 @@ function Combobox(props, ref) {
 
   var updateSelected = (0, _react.useCallback)(function (selectedId) {
     setSelectedValue(selectedId);
-    var newSelected = (0, _utils.getOptionFromOptions)(options, selectedId) || {};
-    setInternalInputValue((0, _get.default)(newSelected, 'label', ''));
+    var newSelected = (0, _utils.getOptionFromOptions)(options, selectedId) || null;
+
+    if (multiple) {
+      var index = selectedValues && selectedValues.findIndex(function (_ref2) {
+        var itemId = _ref2.id;
+        return itemId === selectedId;
+      });
+
+      if (newSelected && (index === undefined || index === -1)) {
+        setSelectedValues((0, _union.default)(selectedValues, [newSelected]));
+      }
+
+      setInternalInputValue('');
+      setActiveId(undefined);
+    } else {
+      setInternalInputValue((0, _get.default)(newSelected, 'label', ''));
+    }
+
+    if (onChangeValue) {
+      if (selectedId) {
+        onChangeValue(selectedId, {
+          removed: false
+        });
+      } else {
+        onChangeValue(null, {
+          removed: true
+        });
+      }
+    }
+  }, [multiple, onChangeValue, options, selectedValues, setInternalInputValue, setSelectedValue, setSelectedValues, setActiveId]);
+  var removeSelected = (0, _react.useCallback)(function (selectedId) {
+    var newSelectedValues = selectedValues && selectedValues.filter(function (_ref3) {
+      var optionId = _ref3.id;
+      return selectedId !== optionId;
+    });
+    setSelectedValues(newSelectedValues);
 
     if (onChangeValue) {
-      onChangeValue(selectedId);
+      onChangeValue(selectedId, {
+        removed: true
+      });
     }
-  }, [onChangeValue, options, setInternalInputValue, setSelectedValue]);
+
+    return undefined;
+  }, [onChangeValue, selectedValues, setSelectedValues]);
   /**
    * If the value prop changes, it should always override any locally maintained current values.
    * This allows the component to be controlled.
@@ -166,15 +291,10 @@ function Combobox(props, ref) {
       setSelectedValue(propValue);
       var newSelected = (0, _utils.getOptionFromOptions)(options, propValue) || {};
       setInternalInputValue((0, _get.default)(newSelected, 'label', ''));
+    } else if (_typeof(propValue) === 'object' && propValue !== selectedValues) {
+      setSelectedValues(propValue);
     }
-  }, [options, propValue, selectedValue, setInternalInputValue, updateSelected]);
-  /**
-   * Toggle the dropdown list.
-   */
-
-  var toggleIsPopoverVisible = (0, _react.useCallback)(function () {
-    setIsPopoverVisible(!isPopoverVisible);
-  }, [isPopoverVisible]);
+  }, [options, propValue, selectedValue, selectedValues, setInternalInputValue, updateSelected]);
   /**
    * This handler is called when the "active" item is changed in the DropdownList. That could be
    * when the user hovers over a new item with the mouse, or when the user navigates through
@@ -190,8 +310,13 @@ function Combobox(props, ref) {
    */
 
   var handleChangeDropdownListValue = (0, _react.useCallback)(function (selectedIds) {
+    if (multiple) {
+      updateSelected((0, _last.default)(selectedIds));
+      return;
+    }
+
     updateSelected(selectedIds[0]);
-  }, [updateSelected]);
+  }, [updateSelected, multiple]);
   /**
    * Clicking anywhere within the Combobox component (except the clear button) should open
    * the dropdown list. There is some complex logic here because of the <input> rendered inside
@@ -211,7 +336,7 @@ function Combobox(props, ref) {
        * tree. Clicking an item in the list will call this click handler on the container.
        * Usually that's fine. In this case, we don't want that behavior.
        */
-      setIsPopoverVisible(false);
+      updateIsPopoverVisible(false);
     } else if (isFocused) {
       if (variant === 'sync' && finalComboboxRef && // @ts-ignore
       finalComboboxRef.current === event.target) {
@@ -227,16 +352,16 @@ function Combobox(props, ref) {
            * This re-opens the popover if you first open it,
            * then make a selection, then click the <input> again.
            */
-          setIsPopoverVisible(true);
+          updateIsPopoverVisible(true);
         }
       } else {
-        toggleIsPopoverVisible();
+        updateIsPopoverVisible('toggle');
       }
     }
 
     onClick && onClick(event);
   }, // eslint-disable-next-line react-hooks/exhaustive-deps
-  [isFocused, isPopoverVisible, variant, onClick, toggleIsPopoverVisible]);
+  [isFocused, isPopoverVisible, variant, onClick, updateIsPopoverVisible]);
   /**
    * This focus handler is responsible for opening the dropdown list and tracking focus state.
    * It's important to do this in the focus handler because the dropdown should open when the
@@ -245,26 +370,12 @@ function Combobox(props, ref) {
 
   var handleContainerFocus = (0, _react.useCallback)(function (event) {
     if (variant === 'sync') {
-      setIsPopoverVisible(true);
+      updateIsPopoverVisible(true);
     }
 
     setIsFocused(true);
     onFocus && onFocus(event);
-  }, [onFocus, setIsPopoverVisible, variant]);
-  /**
-   * This generates a flat list of the options (including those in categories)
-   * in the order they are presented in the dropdown list.
-   */
-
-  var flatOptions = (0, _react.useMemo)(function () {
-    return options.reduce(function (acc, curr) {
-      if ((0, _utils.isCategory)(curr)) {
-        return acc.concat(curr.items);
-      }
-
-      return acc.concat(curr);
-    }, []);
-  }, [options]);
+  }, [onFocus, updateIsPopoverVisible, variant]);
   /**
    * Pressing certain keys when focused on the Combobox component should trigger some actions.
    */
@@ -276,10 +387,10 @@ function Combobox(props, ref) {
       event.preventDefault();
 
       if (!isPopoverVisible) {
-        setIsPopoverVisible(true);
+        updateIsPopoverVisible(true);
       } else {
-        var currentIndex = (0, _findIndex.default)(flatOptions, function (_ref) {
-          var optionId = _ref.id;
+        var currentIndex = (0, _findIndex.default)(flatOptions, function (_ref4) {
+          var optionId = _ref4.id;
           return optionId === activeId;
         });
 
@@ -300,28 +411,28 @@ function Combobox(props, ref) {
     }
 
     if (event.key === 'Enter' && isPopoverVisible) {
-      setIsPopoverVisible(false);
       updateSelected(activeId || '');
+      updateIsPopoverVisible(false);
     }
 
     if (event.key === 'Escape') {
-      setIsPopoverVisible(false);
+      updateIsPopoverVisible(false);
     }
 
     if (event.key === 'Tab' && isPopoverVisible) {
-      setIsPopoverVisible(false);
+      updateIsPopoverVisible(false);
     }
 
     if (onKeyDown) {
       onKeyDown(event);
     }
-  }, [activeId, flatOptions, isPopoverVisible, onKeyDown, setActiveId, updateSelected]); // When the dropdown is visible, clicking anywhere outside of the dropdown should close it.
+  }, [activeId, flatOptions, isPopoverVisible, onKeyDown, updateIsPopoverVisible, updateSelected]); // When the dropdown is visible, clicking anywhere outside of the dropdown should close it.
 
   var handleClickOutsideList = (0, _react.useCallback)(function (event) {
     if (isPopoverVisible) {
-      setIsPopoverVisible(false);
+      updateIsPopoverVisible(false);
     }
-  }, [isPopoverVisible]);
+  }, [isPopoverVisible, updateIsPopoverVisible]);
   (0, _useClickOutside.default)([finalComboboxRef, listRef], handleClickOutsideList);
   /**
    * The DropdownList accepts a prop called `PanelComponent` that can be used
@@ -368,7 +479,12 @@ function Combobox(props, ref) {
 
     return undefined;
   }, [internalInputValue, loading, options, translate]);
-  return _react.default.createElement(_react.default.Fragment, null, _react.default.createElement(_InputField.default, _extends({}, getInputFieldProps(), {
+  var selectedValuesIds = selectedValues ? selectedValues.map(function (elem) {
+    return elem.id || '';
+  }) : undefined;
+  return _react.default.createElement(StyledInputDiv, {
+    maxWidth: maxWidth
+  }, _react.default.createElement(_InputField.default, _extends({}, getInputFieldProps(), {
     id: inputId,
     inputContainerRef: finalInputContainerRef,
     onBlur: function onBlur() {
@@ -378,16 +494,18 @@ function Combobox(props, ref) {
     onClick: handleContainerClick,
     onKeyDown: handleContainerKeyDown,
     ref: finalComboboxRef
-  }), function (_ref2) {
-    var ariaLabelledBy = _ref2['aria-labelledby'],
-        disabled = _ref2.disabled,
-        targetId = _ref2.id,
-        onBlurTarget = _ref2.onBlur,
-        onChangeTargetValue = _ref2.onChange,
-        onFocusTarget = _ref2.onFocus,
-        readOnly = _ref2.readOnly,
-        targetRef = _ref2.ref,
-        value = _ref2.value;
+  }), function (_ref5) {
+    var ariaLabelledBy = _ref5['aria-labelledby'],
+        disabled = _ref5.disabled,
+        targetId = _ref5.id,
+        onBlurTarget = _ref5.onBlur,
+        onChangeTargetValue = _ref5.onChange,
+        onFocusTarget = _ref5.onFocus,
+        readOnly = _ref5.readOnly,
+        targetRef = _ref5.ref,
+        value = _ref5.value,
+        autoComplete = _ref5.autoComplete,
+        type = _ref5.type;
     var dropdownListId = "".concat(targetId, "-dropdown-list");
     return _react.default.createElement(_react.default.Fragment, null, _react.default.createElement(_Target.default, {
       "aria-haspopup": "listbox",
@@ -400,6 +518,9 @@ function Combobox(props, ref) {
       inputFieldLabel: label,
       isPopoverVisible: isPopoverVisible,
       name: name,
+      multiple: multiple,
+      selectedValues: selectedValues,
+      removeSelected: removeSelected,
       onBlur: onBlurTarget,
       onClear: function onClear() {
         onChangeTargetValue();
@@ -411,8 +532,13 @@ function Combobox(props, ref) {
       ref: targetRef,
       value: value,
       variant: variant,
-      toggleIsPopoverVisible: toggleIsPopoverVisible
+      toggleIsPopoverVisible: function toggleIsPopoverVisible() {
+        return updateIsPopoverVisible('toggle');
+      },
+      autoComplete: autoComplete,
+      type: type
     }), _react.default.createElement(_DropdownList.default, {
+      containerSelector: containerSelector,
       PanelComponent: getPanelComponent(),
       activeId: activeId,
       "aria-labelledby": ariaLabelledBy,
@@ -424,10 +550,12 @@ function Combobox(props, ref) {
       listRef: listRef,
       minWidth: "".concat((dimensions.width || 0) + 1, "px"),
       name: "".concat(name, "_dropdown-list"),
+      multiple: multiple,
       onChange: handleChangeDropdownListValue,
       onChangeActiveItem: handleChangeDropdownListActiveItem,
-      selectedIds: selectedValue || '',
+      selectedIds: !multiple ? selectedValue || '' : selectedValuesIds,
       showArrow: false,
+      showCheckbox: !multiple,
       target: popoverTargetRef,
       visible: Boolean(isPopoverVisible || loading),
       renderOptionLabel: renderOptionLabel,
@@ -437,6 +565,8 @@ function Combobox(props, ref) {
 }
 
 var ComboboxWithRef = (0, _react.forwardRef)(Combobox);
-ComboboxWithRef.propTypes = _schema.default.propTypes;
+ComboboxWithRef.propTypes = _objectSpread({}, _schema.default.propTypes, {
+  icon: _propTypes.default.elementType
+});
 var _default = ComboboxWithRef;
 exports.default = _default;