@pingux/astro 1.1.1-alpha.1 → 1.1.1-alpha.5

package/lib/cjs/components/MultivaluesField/MultivaluesField.js

@@ -0,0 +1,519 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty2 = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty2(exports, "__esModule", {
+  value: true
+});
+
+exports["default"] = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/define-property"));
+
+var _defineProperties = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/define-properties"));
+
+var _getOwnPropertyDescriptors = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors"));
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _getOwnPropertyDescriptor = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+
+var _find = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/find"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _defineProperty3 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+
+var _from = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/from"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _CloseIcon = _interopRequireDefault(require("mdi-react/CloseIcon"));
+
+var _i18n = require("@react-aria/i18n");
+
+var _focus = require("@react-aria/focus");
+
+var _list = require("@react-stately/list");
+
+var _overlays = require("@react-aria/overlays");
+
+var _utils = require("@react-aria/utils");
+
+var _uuid = require("uuid");
+
+var _ = require("../..");
+
+var _ListBox = _interopRequireDefault(require("../ListBox"));
+
+var _isIterable = require("../../utils/devUtils/props/isIterable");
+
+var _hooks = require("../../hooks");
+
+var _react2 = require("@emotion/react");
+
+function ownKeys(object, enumerableOnly) { var keys = (0, _keys["default"])(object); if (_getOwnPropertySymbols["default"]) { var symbols = (0, _getOwnPropertySymbols["default"])(object); if (enumerableOnly) symbols = (0, _filter["default"])(symbols).call(symbols, function (sym) { return (0, _getOwnPropertyDescriptor["default"])(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { var _context7; (0, _forEach["default"])(_context7 = ownKeys(Object(source), true)).call(_context7, function (key) { (0, _defineProperty3["default"])(target, key, source[key]); }); } else if (_getOwnPropertyDescriptors["default"]) { (0, _defineProperties["default"])(target, (0, _getOwnPropertyDescriptors["default"])(source)); } else { var _context8; (0, _forEach["default"])(_context8 = ownKeys(Object(source))).call(_context8, function (key) { (0, _defineProperty2["default"])(target, key, (0, _getOwnPropertyDescriptor["default"])(source, key)); }); } } return target; }
+
+/**
+ * Complex control that lets you choose several tags from the dropdown list.
+ * Or to add your own values in non-restrictive mode.
+ *
+ * Combines an input with a Listbox for a filterable dropdown list.
+ *
+ * Utilizes [useListState](https://react-spectrum.adobe.com/react-stately/useListState.html) from React
+ * Stately.
+ */
+var MultivaluesField = /*#__PURE__*/(0, _react.forwardRef)(function (props, ref) {
+  var _context4;
+
+  var defaultSelectedKeys = props.defaultSelectedKeys,
+      direction = props.direction,
+      _props$disabledKeys = props.disabledKeys,
+      disabledKeys = _props$disabledKeys === void 0 ? [] : _props$disabledKeys,
+      hasAutoFocus = props.hasAutoFocus,
+      hasNoStatusIndicator = props.hasNoStatusIndicator,
+      isDisabled = props.isDisabled,
+      isNotFlippable = props.isNotFlippable,
+      isReadOnly = props.isReadOnly,
+      isRequired = props.isRequired,
+      initialItems = props.items,
+      label = props.label,
+      mode = props.mode,
+      _onBlur = props.onBlur,
+      _onFocus = props.onFocus,
+      onInputChange = props.onInputChange,
+      onKeyDown = props.onKeyDown,
+      _onKeyUp = props.onKeyUp,
+      onOpenChange = props.onOpenChange,
+      onSelectionChange = props.onSelectionChange,
+      placeholder = props.placeholder,
+      selectedKeys = props.selectedKeys,
+      scrollBoxProps = props.scrollBoxProps;
+  var hasCustomValue = mode === 'non-restrictive';
+  (0, _hooks.usePropWarning)(props, 'disabled', 'isDisabled');
+
+  var _useState = (0, _react.useState)([]),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      customItems = _useState2[0],
+      setCustomItems = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(''),
+      _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+      filterString = _useState4[0],
+      setFilterString = _useState4[1];
+
+  var _useState5 = (0, _react.useState)(false),
+      _useState6 = (0, _slicedToArray2["default"])(_useState5, 2),
+      isOpen = _useState6[0],
+      setIsOpen = _useState6[1];
+
+  var _useState7 = (0, _react.useState)(initialItems),
+      _useState8 = (0, _slicedToArray2["default"])(_useState7, 2),
+      items = _useState8[0],
+      setItems = _useState8[1];
+
+  var toggleItems = function toggleItems(keys) {
+    setItems((0, _filter["default"])(initialItems).call(initialItems, function (item) {
+      var _context;
+
+      return !(0, _includes["default"])(_context = (0, _from["default"])(keys)).call(_context, item.key);
+    }));
+    setFilterString('');
+    if (onSelectionChange) onSelectionChange(keys);
+  };
+
+  var _useFilter = (0, _i18n.useFilter)({
+    sensitivity: 'base'
+  }),
+      contains = _useFilter.contains;
+
+  var state = (0, _list.useListState)(_objectSpread(_objectSpread({}, props), {}, {
+    filter: function filter(nodes) {
+      var _context2;
+
+      return (0, _filter["default"])(_context2 = (0, _from["default"])(nodes)).call(_context2, function (item) {
+        return contains(item.textValue, filterString);
+      });
+    },
+    items: items,
+    onSelectionChange: toggleItems,
+    selectionMode: 'multiple'
+  }));
+  var selectionManager = state.selectionManager;
+  var filteredItems = (0, _react.useMemo)(function () {
+    return (0, _from["default"])(state.collection);
+  }, [state.collection, filterString]);
+
+  var close = function close() {
+    return setIsOpen(false);
+  };
+
+  var inputRef = (0, _react.useRef)();
+  /* istanbul ignore next */
+
+  (0, _react.useImperativeHandle)(ref, function () {
+    return inputRef.current;
+  });
+  var listBoxRef = (0, _react.useRef)();
+  var popoverRef = (0, _react.useRef)();
+
+  var _useOverlayPosition = (0, _overlays.useOverlayPosition)({
+    isOpen: isOpen,
+    onClose: close,
+    overlayRef: popoverRef,
+    placement: "".concat(direction, " end"),
+    scrollRef: listBoxRef,
+    shouldFlip: !isNotFlippable,
+    targetRef: inputRef
+  }),
+      overlayProps = _useOverlayPosition.overlayProps,
+      placement = _useOverlayPosition.placement,
+      updatePosition = _useOverlayPosition.updatePosition; // Update position once the ListBox has rendered. This ensures that
+  // it flips properly when it doesn't fit in the available space.
+
+  /* istanbul ignore next */
+
+
+  (0, _utils.useLayoutEffect)(function () {
+    if (isOpen) {
+      requestAnimationFrame(function () {
+        updatePosition();
+      });
+    }
+  }, [isOpen, selectionManager.selectedKeys, updatePosition]); // Measure the width of the input to inform the width of the menu (below).
+
+  var _useState9 = (0, _react.useState)(null),
+      _useState10 = (0, _slicedToArray2["default"])(_useState9, 2),
+      menuWidth = _useState10[0],
+      setMenuWidth = _useState10[1];
+
+  var onResize = (0, _react.useCallback)(function () {
+    /* istanbul ignore next */
+    if (inputRef.current) {
+      setMenuWidth(inputRef.current.offsetWidth);
+    }
+  }, [inputRef, isOpen, setMenuWidth]);
+  (0, _utils.useResizeObserver)({
+    ref: inputRef,
+    onResize: onResize
+  });
+  (0, _utils.useLayoutEffect)(onResize, [onResize]);
+
+  var style = _objectSpread(_objectSpread({}, overlayProps.style), {}, {
+    width: menuWidth,
+    minWidth: menuWidth
+  });
+
+  (0, _react.useEffect)(function () {
+    if (defaultSelectedKeys) selectionManager.setSelectedKeys(defaultSelectedKeys);
+  }, []);
+  (0, _react.useEffect)(function () {
+    if (selectedKeys) selectionManager.setSelectedKeys(selectedKeys);
+  }, []);
+  (0, _react.useEffect)(function () {
+    if (onOpenChange) onOpenChange(isOpen);
+  }, [isOpen]);
+  (0, _react.useEffect)(function () {
+    if (!state.collection.size) close();
+  }, [state.collection]);
+  /* istanbul ignore next */
+
+  var keyDown = function keyDown(e) {
+    switch (e.key) {
+      case 'Enter':
+        {
+          if (selectionManager.focusedKey) {
+            var key = selectionManager.focusedKey;
+
+            if (!(0, _includes["default"])(disabledKeys).call(disabledKeys, key)) {
+              selectionManager.toggleSelection(selectionManager.focusedKey);
+              setFilterString('');
+            }
+          } else if (!hasCustomValue && filteredItems.length === 1) {
+            var _key = filteredItems[0].key;
+
+            if (!(0, _includes["default"])(disabledKeys).call(disabledKeys, _key)) {
+              selectionManager.toggleSelection(filteredItems[0].key);
+              setFilterString('');
+            }
+          } else if (hasCustomValue) {
+            var _context3;
+
+            var name = e.target.value;
+            var id = (0, _uuid.v4)();
+            selectionManager.toggleSelection(id);
+            setCustomItems((0, _concat["default"])(_context3 = []).call(_context3, customItems, [{
+              id: id,
+              key: id,
+              name: name
+            }]));
+            setFilterString('');
+          }
+
+          break;
+        }
+
+      case 'ArrowDown':
+        {
+          var nextKey = state.collection.getKeyAfter(selectionManager.focusedKey) || state.collection.getFirstKey();
+          if (nextKey) selectionManager.setFocusedKey(nextKey);
+          break;
+        }
+
+      case 'ArrowUp':
+        {
+          var prevKey = state.collection.getKeyBefore(selectionManager.focusedKey) || state.collection.getLastKey();
+          if (prevKey) selectionManager.setFocusedKey(prevKey);
+          break;
+        }
+
+      default:
+        break;
+    }
+
+    if (onKeyDown) onKeyDown(e.nativeEvent);
+  };
+
+  var deleteItem = function deleteItem(key) {
+    selectionManager.toggleSelection(key);
+  };
+
+  var selectedItems = (0, _react2.jsx)(_react["default"].Fragment, null, (0, _map["default"])(_context4 = (0, _from["default"])(selectionManager.selectedKeys)).call(_context4, function (key) {
+    var _context5, _context6;
+
+    var item = (0, _find["default"])(_context5 = (0, _concat["default"])(_context6 = []).call(_context6, initialItems, customItems)).call(_context5, function (el) {
+      return el.key === key;
+    });
+
+    if (item) {
+      return (0, _react2.jsx)(_.Chip, {
+        key: item.key,
+        role: "presentation",
+        bg: "active",
+        color: "white",
+        label: item.name,
+        sx: {
+          alignSelf: 'center',
+          cursor: 'default',
+          height: '100%',
+          m: 5,
+          mr: 10,
+          py: 2
+        },
+        textProps: {
+          sx: {
+            fontWeight: 500,
+            textTransform: 'none'
+          }
+        }
+      }, (0, _react2.jsx)(_.IconButton, {
+        "aria-label": "delete",
+        onPress: function onPress() {
+          return deleteItem(item.key);
+        },
+        variant: "buttons.chipDeleteButton"
+      }, (0, _react2.jsx)(_.Icon, {
+        icon: _CloseIcon["default"],
+        color: "white",
+        size: 14
+      })));
+    }
+
+    return null;
+  }));
+  var listbox = (0, _react2.jsx)(_focus.FocusScope, {
+    restoreFocus: true
+  }, (0, _react2.jsx)(_overlays.DismissButton, {
+    onDismiss: close
+  }), (0, _react2.jsx)(_.ScrollBox, scrollBoxProps, (0, _react2.jsx)(_ListBox["default"], {
+    ref: listBoxRef,
+    hasAutoFocus: hasAutoFocus,
+    hasVirtualFocus: true,
+    hasNoEmptySelection: true,
+    state: state,
+    "aria-label": "List of options"
+  })), (0, _react2.jsx)(_overlays.DismissButton, {
+    onDismiss: close
+  }));
+  var inputProps = {
+    controlProps: {
+      'aria-expanded': isOpen,
+      role: 'combobox'
+    },
+    hasAutoFocus: hasAutoFocus,
+    hasNoStatusIndicator: hasNoStatusIndicator,
+    isDisabled: isDisabled,
+    isReadOnly: isReadOnly,
+    isRequired: isRequired,
+    label: label,
+    placeholder: placeholder,
+    wrapperProps: {
+      ref: inputRef,
+      variant: 'forms.input.multivaluesWrapper'
+    }
+  };
+  return (0, _react2.jsx)(_react["default"].Fragment, null, (0, _react2.jsx)(_.TextField, (0, _extends2["default"])({
+    onBlur: function onBlur(e) {
+      setIsOpen(false);
+      if (_onBlur) _onBlur(e.nativeEvent);
+    },
+    onChange: function onChange(e) {
+      setIsOpen(true);
+      setFilterString(e.target.value);
+      if (onInputChange) onInputChange(e.target.value);
+    },
+    onFocus: function onFocus(e) {
+      setIsOpen(true);
+      if (_onFocus) _onFocus(e.nativeEvent);
+    },
+    onKeyDown: keyDown,
+    onKeyUp: function onKeyUp(e) {
+      return _onKeyUp && _onKeyUp(e.nativeEvent);
+    },
+    slots: {
+      beforeInput: selectedItems
+    },
+    value: filterString
+  }, inputProps)), (0, _react2.jsx)(_.PopoverContainer, {
+    ref: popoverRef,
+    hasNoArrow: true,
+    isNonModal: true,
+    isOpen: isOpen,
+    placement: placement,
+    style: style
+  }, listbox));
+});
+MultivaluesField.propTypes = {
+  /** The initial selected keys in the collection (uncontrolled). */
+  defaultSelectedKeys: _isIterable.isIterableProp,
+
+  /** Where the menu opens relative to its trigger. */
+  direction: _propTypes["default"].oneOf(['top', 'right', 'bottom', 'left']),
+
+  /**
+   * The item keys that are disabled. These items cannot be selected.
+   */
+  disabledKeys: _isIterable.isIterableProp,
+
+  /** Whether the element should receive focus on render. */
+  hasAutoFocus: _propTypes["default"].bool,
+
+  /** Whether the field has a status indicator. */
+  hasNoStatusIndicator: _propTypes["default"].bool,
+
+  /** Whether the input is disabled. */
+  isDisabled: _propTypes["default"].bool,
+
+  /**
+   * Whether the menu is prevented from flipping directions when insufficient space is
+   * available for the given `direction` placement.
+   */
+  isNotFlippable: _propTypes["default"].bool,
+
+  /** Whether the input can be selected but not changed by the user. */
+  isReadOnly: _propTypes["default"].bool,
+
+  /** Whether user input is required on the input before form submission. */
+  isRequired: _propTypes["default"].bool,
+
+  /** The list of items. */
+  items: _isIterable.isIterableProp,
+
+  /** The rendered label for the field. */
+  label: _propTypes["default"].string,
+
+  /** Whether the component allows to create new values or only choose from the selection list */
+  mode: _propTypes["default"].oneOf(['restrictive', 'non-restrictive']),
+
+  /**
+   * Handler that is called when the element loses focus.
+   *
+   * `(e: FocusEvent) => void`
+   */
+  onBlur: _propTypes["default"].func,
+
+  /**
+   * Handler that is called when the element receives focus.
+   *
+   * `(e: FocusEvent) => void`
+   */
+  onFocus: _propTypes["default"].func,
+
+  /**
+   * Handler that is called when the input value changes.
+   *
+   * `(value: string) => void`
+   */
+  onInputChange: _propTypes["default"].func,
+
+  /**
+   * Handler that is called when a key is pressed.
+   *
+   * `(e: KeyboardEvent) => void`
+   */
+  onKeyDown: _propTypes["default"].func,
+
+  /**
+  * Handler that is called when a key is released.
+  *
+  * `(e: KeyboardEvent) => void`
+  */
+  onKeyUp: _propTypes["default"].func,
+
+  /**
+   * Method that is called when the open state of the menu changes.
+   *
+   * `(isOpen: boolean) => void`
+   */
+  onOpenChange: _propTypes["default"].func,
+
+  /**
+   * Handler that is called when the selection changes.
+   *
+   * `(keys: Iterable<Key>) => any`
+   */
+  onSelectionChange: _propTypes["default"].func,
+
+  /** Temporary text that occupies the text input when it is empty. */
+  placeholder: _propTypes["default"].string,
+
+  /** The currently selected keys in the collection (controlled). */
+  selectedKeys: _isIterable.isIterableProp,
+  // /** Props object that is spread directly into the ScrollBox element. */
+
+  /** @ignore */
+  scrollBoxProps: _propTypes["default"].shape({
+    maxHeight: _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].object, _propTypes["default"].number])
+  })
+};
+MultivaluesField.defaultProps = {
+  direction: 'bottom',
+  mode: 'restrictive',
+  scrollBoxProps: {
+    maxHeight: 300
+  }
+};
+var _default = MultivaluesField;
+exports["default"] = _default;