@ntbjs/react-components 1.3.0-rc.8 → 2.0.0-rc.3

package/esm/components/inputs/MultiLevelCheckboxSelect/MultiLevelCheckboxSelect.js

@@ -0,0 +1,181 @@
+import { objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import React from '../../../node_modules/react/index.js';
+import PropTypes from '../../../node_modules/prop-types/index.js';
+import { MultiLevelCheckboxSelect as MultiLevelCheckboxSelect$2, PopoverContainer, PopoverHeader, SearchContainer, OptionsContainer, MultiLevelCheckboxSelectInput, Label, Placeholder, Item, ItemLabel, ItemRemoveButton } from './MultiLevelCheckboxSelect.styled.js';
+import { ReactComponent as SvgSearch } from '../../../icons/search.svg.js';
+import { ReactComponent as SvgClose } from '../../../icons/close.svg.js';
+import MultiLevelCheckbox, { NodeType, findChildValues } from '../MultiLevelCheckbox/MultiLevelCheckbox.js';
+import { useEventListener } from '../../../hooks/useEventListner.js';
+import { useOnClickOutside } from '../../../hooks/useOnClickOutside.js';
+import useUpdateEffect from '../../../node_modules/@restart/hooks/esm/useUpdateEffect.js';
+import { isFunction } from 'lodash';
+import Popover from '../../data/Popover/Popover.js';
+import TextInput from '../TextInput/TextInput.js';
+import SectionSeparator from '../../layout/SectionSeparator/SectionSeparator.js';
+import { r as react } from '../../../_virtual/index.js';
+
+const _excluded = ["label", "options", "checked", "placeholder", "noResultsText", "onChange", "onParentChange"];
+const MultiLevelCheckboxSelect = React.forwardRef(function MultiLevelCheckboxSelect(_ref, forwardedRef) {
+  let {
+      label,
+      options,
+      checked: checkedProp,
+      placeholder,
+      noResultsText,
+      onChange,
+      onParentChange
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const inputRef = react.exports.useRef(null);
+  const popoverContentRef = react.exports.useRef(null);
+  const searchInputRef = react.exports.useRef(null);
+  const [searchString, setSearchString] = react.exports.useState('');
+  const [open, setOpen] = react.exports.useState(false);
+  const handleClickInside = react.exports.useCallback(() => {
+    var _searchInputRef$curre;
+    setOpen(true);
+    (_searchInputRef$curre = searchInputRef.current) === null || _searchInputRef$curre === void 0 || _searchInputRef$curre.focus();
+  }, []);
+  const handleKeyDown = react.exports.useCallback(event => {
+    if (!open) return;
+    if (event.key === 'Escape') {
+      setOpen(false);
+    }
+  }, [open]);
+  useEventListener('focus', handleClickInside, inputRef);
+  useEventListener('mousedown', handleClickInside, inputRef);
+  useEventListener('keydown', handleKeyDown);
+  const handleClickOutside = event => {
+    var _popoverContentRef$cu;
+    if ((popoverContentRef === null || popoverContentRef === void 0 ? void 0 : popoverContentRef.current) === event.target || popoverContentRef !== null && popoverContentRef !== void 0 && (_popoverContentRef$cu = popoverContentRef.current) !== null && _popoverContentRef$cu !== void 0 && _popoverContentRef$cu.contains(event.target)) {
+      return;
+    }
+    setOpen(false);
+  };
+  useOnClickOutside(inputRef, handleClickOutside);
+  const checked = react.exports.useMemo(() => {
+    const checkedParents = [];
+    function iterate(nodes) {
+      nodes.forEach(node => {
+        if (checkedProp.includes(node.value)) {
+          return checkedParents.push(node.value);
+        }
+        if (node.children) {
+          iterate(node.children);
+        }
+      });
+    }
+    iterate(options);
+    return checkedParents.sort();
+  }, [JSON.stringify(options), JSON.stringify(checkedProp)]);
+  const getLabelByValue = react.exports.useCallback((targetValue, nodes = options) => {
+    for (const node of nodes) {
+      if (node.value === targetValue) {
+        return node.label;
+      }
+      if (node.children) {
+        const result = getLabelByValue(targetValue, node.children);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return null;
+  }, [options]);
+  const removeItem = react.exports.useCallback(value => {
+    let node = null;
+    function findNodeByValue(options, value) {
+      for (let i = 0; i < options.length; i++) {
+        if (options[i].value === value) {
+          node = options[i];
+          break;
+        }
+        if (options[i].children) {
+          findNodeByValue(options[i].children, value);
+        }
+      }
+    }
+    findNodeByValue(options, value);
+    if (node) {
+      const childValues = findChildValues(node);
+      const valuesToRemove = [value, ...childValues];
+      onChange(checkedProp.filter(value => !valuesToRemove.includes(value)));
+    }
+  }, [options, checkedProp]);
+  useUpdateEffect(() => {
+    if (isFunction(onParentChange)) {
+      onParentChange(checked);
+    }
+  }, [checked]);
+  return React.createElement(MultiLevelCheckboxSelect$2, _extends({
+    ref: forwardedRef
+  }, props), React.createElement(Popover, {
+    visible: open,
+    arrow: false,
+    placement: 'bottom',
+    offset: [0, 6],
+    modifiers: [{
+      name: 'sameWidth',
+      enabled: true,
+      phase: 'beforeWrite',
+      requires: ['computeStyles'],
+      fn: ({
+        state
+      }) => {
+        state.styles.popper.width = `${state.rects.reference.width}px`;
+      },
+      effect: ({
+        state
+      }) => {
+        state.elements.popper.style.width = `${state.elements.reference.offsetWidth}px`;
+      }
+    }],
+    content: React.createElement(PopoverContainer, {
+      ref: popoverContentRef
+    }, React.createElement(PopoverHeader, null, React.createElement(SearchContainer, null, React.createElement(TextInput, {
+      ref: searchInputRef,
+      onBlur: e => {
+        if (open) {
+          e.target.focus();
+        }
+      },
+      icon: React.createElement(SvgSearch, null),
+      value: searchString,
+      onChange: e => setSearchString(e.target.value)
+    })), React.createElement(SectionSeparator, null)), React.createElement(OptionsContainer, null, React.createElement(MultiLevelCheckbox, {
+      options: options,
+      checked: checkedProp,
+      search: searchString,
+      noResultsText: noResultsText,
+      onChange: onChange
+    })))
+  }, React.createElement(MultiLevelCheckboxSelectInput, {
+    tabIndex: "0",
+    ref: inputRef
+  }, label && React.createElement(Label, null, label), checked.length === 0 && React.createElement(Placeholder, null, placeholder), checked.map(option => React.createElement(Item, {
+    key: option
+  }, React.createElement(ItemLabel, null, getLabelByValue(option)), React.createElement(ItemRemoveButton, {
+    onClick: () => {
+      removeItem(option);
+    }
+  }, React.createElement(SvgClose, null)))))));
+});
+MultiLevelCheckboxSelect.propTypes = process.env.NODE_ENV !== "production" ? {
+  label: PropTypes.string,
+  placeholder: PropTypes.string,
+  options: PropTypes.arrayOf(PropTypes.shape({
+    label: PropTypes.string.isRequired,
+    value: PropTypes.any.isRequired,
+    children: PropTypes.arrayOf(NodeType)
+  })).isRequired,
+  checked: PropTypes.array.isRequired,
+  noResultsText: PropTypes.string,
+  onChange: PropTypes.func.isRequired,
+  onParentChange: PropTypes.func
+} : {};
+MultiLevelCheckboxSelect.defaultProps = {
+  checked: []
+};
+var MultiLevelCheckboxSelect$1 = MultiLevelCheckboxSelect;
+
+export { MultiLevelCheckboxSelect$1 as default };

package/esm/components/inputs/MultiLevelCheckboxSelect/MultiLevelCheckboxSelect.styled.js

@@ -0,0 +1,104 @@
+import styled from 'styled-components';
+import { applyDefaultTheme } from '../../../utils/defaultTheme.js';
+
+let _ = t => t,
+  _t,
+  _t2,
+  _t3,
+  _t4,
+  _t5,
+  _t6,
+  _t7,
+  _t8,
+  _t9,
+  _t10,
+  _t11;
+const MultiLevelCheckboxSelect = styled.div.attrs(applyDefaultTheme)(_t || (_t = _`
+  font-family: ${0};
+`), props => props.theme.primaryFontFamily);
+const MultiLevelCheckboxSelectInput = styled.div.attrs(applyDefaultTheme)(_t2 || (_t2 = _`
+  position: relative;
+  border: 1px solid;
+  ${0}
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  min-height: 44px;
+  box-sizing: border-box;
+  padding: 8px 6px;
+  border-radius: 3px;
+  transition: border-color 350ms;
+
+  &:focus-within {
+    ${0}
+  }
+`), props => props.theme.themeProp('border-color', props.theme.getColor('gray-500'), props.theme.getColor('gray-400')), props => props.theme.themeProp('border-color', props.theme.getColor('gray-500'), props.theme.getColor('gray-600'), 1));
+const Item = styled.div.attrs(applyDefaultTheme)(_t3 || (_t3 = _`
+  display: flex;
+  align-items: center;
+  background: #272727;
+  color: #f7f8f9;
+  font-size: 12px;
+  height: 26px;
+  border-radius: 3px;
+`));
+const ItemLabel = styled.div.attrs(applyDefaultTheme)(_t4 || (_t4 = _`
+  padding: 0 5px 0 8px;
+`));
+const ItemRemoveButton = styled.button.attrs(applyDefaultTheme)(_t5 || (_t5 = _`
+  color: inherit;
+  border: none;
+  background: none;
+  -webkit-appearance: none;
+  height: 100%;
+  border-top-right-radius: 3px;
+  border-bottom-right-radius: 3px;
+  padding: 0 7px;
+  cursor: pointer;
+
+  &:hover {
+    background: ${0};
+  }
+
+  & > svg {
+    width: 8px;
+    display: block;
+  }
+`), props => props.theme.getColor('red-500'));
+const Label = styled.div.attrs(applyDefaultTheme)(_t6 || (_t6 = _`
+  position: absolute;
+  top: -8px;
+  left: 7px;
+  line-height: 1.2;
+  font-size: 0.75rem;
+  font-weight: 400;
+  padding: 0 3px;
+  //padding: 0 0 4px;
+  letter-spacing: 0.03em;
+  ${0}
+  ${0}
+`), props => props.theme.themeProp('color', props.theme.getColor('gray-300'), props.theme.getColor('gray-600')), props => props.theme.themeProp('background', `linear-gradient(0deg, ${props.theme.getColor('gray-900')} calc(50% + 1px), transparent 50%)`, `linear-gradient(0deg, ${props.theme.getColor('white')} calc(50% + 1px), transparent 50%)`));
+const Placeholder = styled.div.attrs(applyDefaultTheme)(_t7 || (_t7 = _`
+  font-size: 0.875rem;
+  line-height: 26px;
+  padding-left: 4px;
+  opacity: 0.4;
+`));
+const PopoverContainer = styled.div.attrs(applyDefaultTheme)(_t8 || (_t8 = _`
+  max-height: inherit;
+  display: flex;
+  flex-direction: column;
+`));
+const PopoverHeader = styled.div.attrs(applyDefaultTheme)(_t9 || (_t9 = _`
+  ${0}
+`), props => props.theme.themeProp('background', props.theme.getColor('gray-700'), props.theme.getColor('white')));
+const SearchContainer = styled.div.attrs(applyDefaultTheme)(_t10 || (_t10 = _`
+  padding: 12px 8px;
+`));
+const OptionsContainer = styled.div.attrs(applyDefaultTheme)(_t11 || (_t11 = _`
+  padding: 12px 8px;
+  overflow: auto;
+  box-sizing: border-box;
+`));
+
+export { Item, ItemLabel, ItemRemoveButton, Label, MultiLevelCheckboxSelect, MultiLevelCheckboxSelectInput, OptionsContainer, Placeholder, PopoverContainer, PopoverHeader, SearchContainer };

package/esm/components/inputs/MultiSelect/MultiSelect.js

@@ -0,0 +1,247 @@
+import { objectWithoutProperties as _objectWithoutProperties, extends as _extends } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import React from '../../../node_modules/react/index.js';
+import PropTypes from '../../../node_modules/prop-types/index.js';
+import { nanoid } from 'nanoid';
+import { MultiSelectWrapper, AsyncCreatableMultiSelect, AsyncMultiSelect, CreatableMultiSelect, MultiSelect as MultiSelect$2, ShowMoreWrapper, ShowMoreOverlay, ShowMoreText, ErrorMessage, MultiValueRemove as MultiValueRemove$1, DropdownMenu, Option as Option$1, SelectedOption as SelectedOption$1, DropdownOptionDeleteIcon, Control, Label, ValueContainer, MultiValueWrapper, MultiValue, Input } from './MultiSelect.styled.js';
+import { ReactComponent as SvgClose } from '../../../icons/close.svg.js';
+import { r as react } from '../../../_virtual/index.js';
+
+const _excluded = ["label", "selectedOptions", "availableOptions", "loadOptions", "loadingMessageFunc", "onUpdateCallback", "editText", "createNewOptionMessageFunc", "noOptionsMessageFunc", "onMultiValueClick", "showMore", "showMoreText", "displayTotalOnShowMore", "creatable", "readOnly", "hidden", "disabled", "error", "warning"];
+const MultiSelect = React.forwardRef(function MultiSelect(_ref, forwardedRef) {
+  let {
+      label,
+      selectedOptions,
+      availableOptions,
+      loadOptions,
+      loadingMessageFunc,
+      onUpdateCallback,
+      editText,
+      createNewOptionMessageFunc,
+      noOptionsMessageFunc,
+      onMultiValueClick,
+      showMore,
+      showMoreText,
+      displayTotalOnShowMore,
+      creatable,
+      readOnly,
+      hidden,
+      disabled,
+      error,
+      warning
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const [uniqueId] = react.exports.useState(nanoid());
+  const [selected, setSelected] = react.exports.useState(selectedOptions);
+  const [focused, setFocused] = react.exports.useState(false);
+  const [displayShowMore, setDisplayShowMore] = react.exports.useState(error || warning ? false : showMore);
+  const [cacheUnique, setCacheUnique] = react.exports.useState(0);
+  react.exports.useEffect(() => {
+    setSelected(selectedOptions);
+  }, [selectedOptions]);
+  const handleShowMoreClick = () => {
+    setDisplayShowMore(false);
+  };
+  const Control$1 = react.exports.useMemo(() => {
+    const ControlWrapper = innerProps => {
+      return React.createElement(Control, _extends({
+        className: "multi-select-control",
+        readOnly: readOnly
+      }, innerProps));
+    };
+    ControlWrapper.displayName = 'ControlWrapper';
+    return ControlWrapper;
+  }, []);
+  const ValueContainer$1 = react.exports.useMemo(() => {
+    const ValueContainerWrapper = innerProps => {
+      return React.createElement(React.Fragment, null, label && React.createElement(Label, {
+        htmlFor: uniqueId
+      }, label), React.createElement(ValueContainer, _extends({
+        showMore: displayShowMore,
+        error: error,
+        warning: warning,
+        className: "multi-select-values-container"
+      }, innerProps)));
+    };
+    ValueContainerWrapper.displayName = 'ValueContainerWrapper';
+    return ValueContainerWrapper;
+  }, [displayShowMore, error, warning]);
+  const MultiValue$1 = innerProps => {
+    return React.createElement(MultiValueWrapper, {
+      className: "multi-value-wrapper",
+      onMouseDown: e => {
+        e.stopPropagation();
+        if (onMultiValueClick && innerProps.data && !(e.target.role === 'button' || e.target instanceof SVGElement)) {
+          onMultiValueClick(innerProps.data);
+        }
+      }
+    }, React.createElement(MultiValue, _extends({
+      className: "multi-value",
+      readOnly: readOnly
+    }, innerProps)));
+  };
+  const Input$1 = react.exports.useMemo(() => {
+    const InputWrapper = innerProps => {
+      return React.createElement(Input, _extends({
+        className: "multi-select-input",
+        $focused: focused,
+        edittext: editText
+      }, innerProps, {
+        isDisabled: readOnly || disabled
+      }));
+    };
+    InputWrapper.displayName = 'InputWrapper';
+    return InputWrapper;
+  }, [focused]);
+  const innerComponents = {
+    DropdownIndicator: null,
+    Control: Control$1,
+    MultiValue: MultiValue$1,
+    MultiValueRemove: innerProps => {
+      return readOnly || disabled ? false : MultiValueRemove(innerProps);
+    },
+    ValueContainer: ValueContainer$1,
+    Input: Input$1,
+    Menu,
+    Option: innerProps => {
+      return innerProps.isSelected ? SelectedOption(innerProps) : Option(innerProps);
+    }
+  };
+  const sharedSelectProps = {
+    ref: forwardedRef,
+    value: selected,
+    options: loadOptions ? undefined : availableOptions,
+    loadOptions: loadOptions,
+    loadingMessage: loadingMessageFunc,
+    editText: editText,
+    formatCreateLabel: createNewOptionMessageFunc,
+    showMore: displayShowMore,
+    readOnly: readOnly,
+    isDisabled: disabled,
+    components: innerComponents,
+    focused: focused,
+    isMulti: true,
+    isClearable: false,
+    placeholder: null,
+    closeMenuOnSelect: false,
+    hideSelectedOptions: false,
+    cacheUniqs: loadOptions ? [cacheUnique] : undefined,
+    onFocus: () => setFocused(true),
+    onBlur: () => setFocused(false),
+    noOptionsMessage: input => {
+      return noOptionsMessageFunc(input.inputValue);
+    },
+    onChange: (selectedOptions, actionMeta) => {
+      switch (actionMeta.action) {
+        case 'create-option':
+          if (onUpdateCallback) {
+            onUpdateCallback(actionMeta.action, actionMeta.option);
+          }
+          if (loadOptions) {
+            setCacheUnique(cacheUnique + 1);
+          }
+          setSelected(selectedOptions);
+          break;
+        case 'select-option':
+          if (onUpdateCallback) {
+            onUpdateCallback(actionMeta.action, actionMeta.option);
+          }
+          setSelected(selectedOptions);
+          break;
+        case 'remove-value':
+          if (onUpdateCallback) {
+            onUpdateCallback(actionMeta.action, actionMeta.removedValue);
+          }
+          setSelected(selectedOptions);
+          break;
+        case 'pop-value':
+          if (onUpdateCallback) {
+            onUpdateCallback(actionMeta.action, actionMeta.removedValue);
+          }
+          setSelected(selectedOptions);
+          break;
+        case 'deselect-option':
+          if (onUpdateCallback) {
+            onUpdateCallback(actionMeta.action, actionMeta.option);
+          }
+          setSelected(selectedOptions);
+          break;
+        case 'clear':
+          break;
+        default:
+          if (onUpdateCallback) {
+            onUpdateCallback(actionMeta.action, actionMeta.option);
+          }
+          setSelected(selectedOptions);
+          break;
+      }
+    }
+  };
+  if (hidden) return null;
+  return React.createElement(MultiSelectWrapper, {
+    error: error,
+    warning: warning
+  }, loadOptions ? creatable ? React.createElement(AsyncCreatableMultiSelect, _extends({}, sharedSelectProps, props)) : React.createElement(AsyncMultiSelect, _extends({}, sharedSelectProps, props)) : creatable ? React.createElement(CreatableMultiSelect, _extends({}, sharedSelectProps, props)) : React.createElement(MultiSelect$2, _extends({}, sharedSelectProps, props)), displayShowMore && !(error || warning) && React.createElement(ShowMoreWrapper, {
+    onClick: handleShowMoreClick
+  }, React.createElement(ShowMoreOverlay, null), React.createElement(ShowMoreText, null, showMoreText, " ", displayTotalOnShowMore && '(' + selected.length + ')')), (typeof error === 'string' || typeof warning === 'string') && React.createElement(ErrorMessage, {
+    error: error,
+    warning: warning
+  }, error ? error : warning));
+});
+MultiSelect.propTypes = process.env.NODE_ENV !== "production" ? {
+  label: PropTypes.string,
+  availableOptions: PropTypes.arrayOf(PropTypes.object),
+  selectedOptions: PropTypes.arrayOf(PropTypes.object),
+  loadOptions: PropTypes.func,
+  loadingMessageFunc: PropTypes.func,
+  onUpdateCallback: PropTypes.func,
+  editText: PropTypes.string.isRequired,
+  creatable: PropTypes.bool,
+  createNewOptionMessageFunc: PropTypes.func,
+  noOptionsMessageFunc: PropTypes.func,
+  onMultiValueClick: PropTypes.func,
+  showMore: PropTypes.bool,
+  showMoreText: PropTypes.string,
+  displayTotalOnShowMore: PropTypes.bool,
+  readOnly: PropTypes.bool,
+  hidden: PropTypes.bool,
+  disabled: PropTypes.bool,
+  error: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  warning: PropTypes.oneOfType([PropTypes.bool, PropTypes.string])
+} : {};
+MultiSelect.defaultProps = {
+  noOptionsMessageFunc: inputValue => {
+    if (inputValue) {
+      return `No matches for "${inputValue}"`;
+    } else {
+      return 'No available options';
+    }
+  },
+  showMore: false,
+  displayTotalOnShowMore: true,
+  readOnly: false,
+  disabled: false,
+  creatable: false,
+  error: false,
+  warning: false,
+  showMoreText: 'Show more',
+  hidden: false
+};
+const MultiValueRemove = innerProps => {
+  return React.createElement(MultiValueRemove$1, innerProps, React.createElement(SvgClose, {
+    className: "multi-value-remove-icon"
+  }));
+};
+const Menu = innerProps => {
+  return React.createElement(DropdownMenu, innerProps);
+};
+const Option = innerProps => {
+  return React.createElement(Option$1, _extends({
+    className: "multi-select-dropdown-item"
+  }, innerProps));
+};
+const SelectedOption = innerProps => {
+  return React.createElement(SelectedOption$1, innerProps, innerProps.label, React.createElement(DropdownOptionDeleteIcon, null));
+};
+var MultiSelect$1 = MultiSelect;
+
+export { MultiSelect$1 as default };