@elliemae/ds-menu 2.3.0-alpha.6 → 2.3.0-next.0

package/esm/MenuItems/MenuItemCheckable.js

@@ -0,0 +1,108 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import 'react';
+import { PropTypes, describe } from 'react-desc';
+import { Checkmark } from '@elliemae/ds-icons';
+import { runAll } from '@elliemae/ds-utilities';
+import MenuItem from './MenuItem.js';
+import { jsx } from 'react/jsx-runtime';
+
+var _div;
+
+const _excluded = ["role", "checked", "name", "checkIcon", "children", "leftAddon", "item"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function useCheckable(_ref) {
+  let {
+    checked
+  } = _ref;
+  return {
+    checked,
+    'aria-checked': checked
+  };
+}
+/**
+ * Reuses the same props as the MenuItem
+ *
+ * @param root0
+ * @param root0.role
+ * @param root0.checked
+ * @param root0.name
+ * @param root0.checkIcon
+ * @param root0.children
+ * @param root0.leftAddon
+ * @param root0.item
+ */
+
+
+function MenuItemCheckable(_ref2) {
+  let {
+    role = 'menuitemcheckbox',
+    checked = false,
+    name = '',
+    checkIcon = /*#__PURE__*/_jsx(Checkmark, {
+      color: ['brand-primary', 600]
+    }),
+    // eslint-disable-next-line react/prop-types
+    children,
+    leftAddon,
+    item = undefined
+  } = _ref2,
+      otherProps = _objectWithoutProperties(_ref2, _excluded);
+
+  const checkableProps = useCheckable({
+    checked,
+    name
+  });
+
+  const handleClick = () => runAll(otherProps.onClick, checkableProps.onClick)({
+    target: {
+      value: name,
+      checked
+    }
+  }, item);
+
+  const checkAddon = leftAddon || (checkableProps.checked ? /*#__PURE__*/_jsx("div", {
+    className: "checkable-mark"
+  }, void 0, checkIcon) : _div || (_div = /*#__PURE__*/_jsx("div", {})));
+  return /*#__PURE__*/jsx(MenuItem, _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, item), otherProps), checkableProps), {}, {
+    customRenderer: item && item.customRenderer ? item.customRenderer : () => {},
+    items: otherProps.subItems,
+    leftAddon: checkAddon,
+    onClick: handleClick,
+    role: role
+  }));
+}
+
+const props = {
+  /** Whether the item is checked or not */
+  checked: PropTypes.bool.description('Whether the item is checked or not'),
+
+  /** A custom item when the item is checked */
+  checkIcon: PropTypes.element.description('A custom item when the item is checked'),
+
+  /** form field name */
+  name: PropTypes.string.description('form field name'),
+
+  /** menu item object props */
+  item: PropTypes.object.description('menu item object props'),
+
+  /** a11y role */
+  role: PropTypes.string.description('a11y role'),
+
+  /** left addon component */
+  leftAddon: PropTypes.node.description('left addon component')
+};
+const DSMenuItemCheckeableWithSchema = describe(MenuItemCheckable);
+DSMenuItemCheckeableWithSchema.propTypes = props;
+
+export { DSMenuItemCheckeableWithSchema, MenuItemCheckable as default };

package/esm/MenuItems/MenuItemCheckbox.js

@@ -0,0 +1,34 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import 'react';
+import { DSCheckbox } from '@elliemae/ds-form';
+import MenuItemCheckable from './MenuItemCheckable.js';
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["checked"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function MenuItemCheckbox(_ref) {
+  let {
+    checked
+  } = _ref,
+      rest = _objectWithoutProperties(_ref, _excluded);
+
+  return /*#__PURE__*/jsx(MenuItemCheckable, _objectSpread(_objectSpread({}, rest), {}, {
+    leftAddon: /*#__PURE__*/_jsx(DSCheckbox, {
+      checked: checked
+    }),
+    role: "menuitemcheckbox"
+  }));
+}
+
+export { MenuItemCheckbox as default };

package/esm/MenuItems/MenuItemRadio.js

@@ -0,0 +1,32 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'react';
+import { PropTypes, describe } from 'react-desc';
+import MenuItemCheckable from './MenuItemCheckable.js';
+import { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function MenuItemRadio(props) {
+  return /*#__PURE__*/jsx(MenuItemCheckable, _objectSpread(_objectSpread({}, props), {}, {
+    role: "menuitemradio"
+  }));
+}
+
+const props = {
+  /** Whether the item is checked or not */
+  checked: PropTypes.bool.description('Whether the item is checked or not'),
+
+  /** A custom item when the item is checked */
+  checkIcon: PropTypes.element.description('A custom item when the item is checked')
+};
+const DSMenuItemRadioWithSchema = describe(MenuItemCheckable);
+DSMenuItemRadioWithSchema.propTypes = props;
+
+export { DSMenuItemRadioWithSchema, MenuItemRadio as default };

package/esm/MenuItems/RadioGroup.js

@@ -0,0 +1,32 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'react';
+import { PropTypes, describe } from 'react-desc';
+import CheckableGroup from '@elliemae/ds-shared/CheckableGroup';
+import { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function RadioGroup(props) {
+  return /*#__PURE__*/jsx(CheckableGroup, _objectSpread(_objectSpread({}, props), {}, {
+    multi: false
+  }));
+}
+
+const props = {
+  /* The item selected */
+  active: PropTypes.arrayOf(PropTypes.string).description('the item selected'),
+
+  /* Handler when a user checks an item */
+  onCheck: PropTypes.func.description('Handler when a user checks an item')
+};
+const DSMenuRadioGroupWithSchema = describe(RadioGroup);
+DSMenuRadioGroupWithSchema.propTypes = props;
+
+export { DSMenuRadioGroupWithSchema, RadioGroup as default };

package/esm/MenuItems/SearchableGroup.js

@@ -0,0 +1,91 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import { useRef, useState, useEffect, useContext, useMemo } from 'react';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import { focusGroupManagerHoc } from '@elliemae/ds-shared/FocusGroup';
+import DSSearchBox from '@elliemae/ds-form/SearchBox';
+import { PropTypes, describe } from 'react-desc';
+import VirtualMenuList from '../VirtualMenuList.js';
+import MenuContext from '../MenuContext.js';
+import { jsxs, Fragment } from 'react/jsx-runtime';
+
+const SearchBoxWrapper = aggregatedClasses('div')('menu-search-group', 'search-wrapper');
+const NoOptionsWrapper = aggregatedClasses('div')('menu-search-group', 'no-options');
+
+function SearchableGroup(_ref) {
+  let {
+    children,
+    amountItemsInWindow = 5,
+    searchTerm: searchTermProp = '',
+    noOptionsText = 'No options',
+    height,
+    width,
+    focusOnOpen = false
+  } = _ref;
+  const searchRef = useRef(null);
+  const [searchTerm, setSearchTerm] = useState(searchTermProp);
+  useEffect(() => {
+    if (searchRef.current) searchRef.current.focus();
+  }, []);
+  const {
+    visible
+  } = useContext(MenuContext) || {};
+  useEffect(() => {
+    if (focusOnOpen && visible) {
+      setTimeout(() => {
+        if (searchRef.current) searchRef.current.focus();
+      }, 0);
+    }
+  }, [focusOnOpen, visible]);
+  const filteredChildren = useMemo(() => children.filter(child => !searchTerm || child.props.label.toLowerCase().startsWith(searchTerm.toLowerCase())), [children, searchTerm]);
+  return /*#__PURE__*/jsxs(Fragment, {
+    children: [/*#__PURE__*/_jsx(SearchBoxWrapper, {}, void 0, /*#__PURE__*/_jsx(DSSearchBox, {
+      innerRef: searchRef,
+      onSearch: _ref2 => {
+        let {
+          value
+        } = _ref2;
+        return setSearchTerm(value);
+      },
+      searchOnEnter: false,
+      showIcon: false,
+      value: searchTerm
+    })), !filteredChildren.length && /*#__PURE__*/_jsx(NoOptionsWrapper, {}, void 0, noOptionsText), /*#__PURE__*/_jsx(VirtualMenuList, {
+      amountItemsInWindow: amountItemsInWindow,
+      height: height,
+      items: filteredChildren,
+      width: width
+    })]
+  });
+}
+
+const props = {
+  /** The amount of items that are going to be rendered in the group */
+  amountItemsInWindow: PropTypes.number.description('The amount of items that are going to be rendered in the group'),
+
+  /** A search term */
+  searchTerm: PropTypes.string.description('A search term'),
+
+  /** Text to show when there's no options to show */
+  noOptionsText: PropTypes.string.description("Text to show when there's no options to show"),
+
+  /** array of children for search list */
+  children: PropTypes.array.description('array of children for search list'),
+
+  /** height for virtual list wrapper */
+  height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('height for virtual list wrapper'),
+
+  /** width for virtual list wrapper */
+  width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).description('width for virtual list wrapper'),
+
+  /** weather to focus on searchable group on open */
+  focusOnOpen: PropTypes.bool.description('weather to focus on searchable group on open')
+};
+const DSMenuSearchableGroupWithSchema = describe(SearchableGroup);
+DSMenuSearchableGroupWithSchema.propTypes = props;
+var SearchableGroup$1 = focusGroupManagerHoc(SearchableGroup);
+
+export { DSMenuSearchableGroupWithSchema, SearchableGroup$1 as default };

package/esm/MenuItems/SearchableList.js

@@ -0,0 +1,108 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useCallback, useMemo } from 'react';
+import { PropTypes, describe } from 'react-desc';
+import { uniqBy } from '@elliemae/ds-utilities';
+import { DSComboBox } from '@elliemae/ds-form';
+import { jsx } from 'react/jsx-runtime';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const noop = () => {};
+
+function SearchableList(_ref) {
+  let {
+    onSelectMenuItem = noop,
+    components = {},
+    searchTerm: searchTermProp = '',
+    items = [],
+    dropdownFilterOptions = {},
+    returnValue,
+    extraListProps = {},
+    appendTermInList = false,
+    maxOptions = 10,
+    loading = false
+  } = _ref;
+  const [searchTerm, setInputValue] = useState(searchTermProp);
+  const handleInputChange = useCallback((value, args) => {
+    const action = args ? args.action : null;
+    if (action === 'input-blur' || action === 'menu-close') return;
+    setInputValue(value);
+  }, [searchTerm]);
+  const handleFilterByText = useCallback(() => {
+    if (searchTerm) onSelectMenuItem(searchTerm);
+  }, [searchTerm]);
+  const handleKeyDown = useCallback(e => {
+    if (e.key === 'ArrowRight') {
+      handleFilterByText();
+    }
+  }, [searchTerm]);
+  const options = useMemo(() => searchTerm && appendTermInList ? uniqBy([{
+    id: searchTerm,
+    label: searchTerm
+  }].concat(items), item => item.label) : items, [searchTerm, appendTermInList]);
+  return /*#__PURE__*/jsx(DSComboBox, _objectSpread(_objectSpread({
+    autoFocus: true,
+    components: _objectSpread({
+      DropdownIndicator: null
+    }, components),
+    customMenuItemOptions: {
+      useTruncatedText: true
+    },
+    inlineMenu: true,
+    inputValue: searchTerm,
+    menuIsOpen: true,
+    onChange: onSelectMenuItem,
+    onFilterByInputText: handleFilterByText,
+    onInputChange: handleInputChange,
+    onKeyDown: handleKeyDown,
+    options: options,
+    returnValue: returnValue,
+    valueProperty: "id",
+    maxOptions: maxOptions,
+    loading: loading
+  }, extraListProps), dropdownFilterOptions));
+}
+
+const props = {
+  /** callback after item gets selected */
+  onSelectMenuItem: PropTypes.func.description('callback after item gets selected'),
+
+  /** Object with custom components for react-select */
+  components: PropTypes.shape({}).description('Object with custom components for react-select'),
+
+  /** search term to filter for */
+  searchTerm: PropTypes.string.description('search term to filter for'),
+
+  /** item options */
+  items: PropTypes.array.description('item options'),
+
+  /** options */
+  dropdownFilterOptions: PropTypes.shape({}).description('options'),
+
+  /** Whether the combo box is has value to return or not */
+  returnValue: PropTypes.bool.description('Whether the combo box is has value to return or not'),
+
+  /** extra props to pass down to combo */
+  extraListProps: PropTypes.shape({}).description('extra props to pass down to combo'),
+
+  /** append search term as item on the list */
+  appendTermInList: PropTypes.bool.description('append search term as item on the list'),
+
+  /** maxoptions for combobox */
+  maxOptions: PropTypes.number.description('maxoptions for combobox'),
+
+  /**  loading flag */
+  loading: PropTypes.bool.description('loading flag')
+};
+const DSMenuSearchableListWithSchema = describe(SearchableList);
+DSMenuSearchableListWithSchema.propTypes = props;
+
+export { DSMenuSearchableListWithSchema, SearchableList as default };

package/esm/MenuItems/SelectionGroup.js

@@ -0,0 +1,97 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useMemo, createElement } from 'react';
+import { PropTypes, describe } from 'react-desc';
+import { useCheckableGroup } from '@elliemae/ds-shared/CheckableGroup';
+import SearchableGroup from './SearchableGroup.js';
+import { menuItemFactory } from './menuItemFactory.js';
+import VirtualMenuList from '../VirtualMenuList.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const noop = () => null;
+
+function SelectionGroup(_ref) {
+  let {
+    multi = false,
+    searchable = false,
+    focusOnOpen = false,
+    onSelect = noop,
+    children,
+    items = undefined,
+    active = multi ? [] : '',
+    width,
+    height,
+    maxOptions = 5
+  } = _ref;
+  const renderedItems = useMemo(() => items && items.map(item => {
+    const Component = menuItemFactory(multi ? 'checkbox' : 'radio');
+    return /*#__PURE__*/createElement(Component, _objectSpread(_objectSpread({}, item), {}, {
+      key: item.name || item.id || item.key,
+      item: item,
+      name: item.id || item.name
+    }));
+  }), [items]);
+  const decoratedGroupChildren = useCheckableGroup({
+    children: renderedItems || children,
+    multi,
+    active,
+    onCheck: onSelect
+  });
+
+  if (searchable) {
+    return /*#__PURE__*/_jsx(SearchableGroup, {
+      focusOnOpen: focusOnOpen,
+      height: height,
+      items: items,
+      width: width
+    }, void 0, decoratedGroupChildren);
+  }
+
+  return /*#__PURE__*/_jsx(VirtualMenuList, {
+    height: height,
+    items: decoratedGroupChildren,
+    width: width,
+    amountItemsInWindow: maxOptions
+  });
+}
+
+const props = {
+  /** toggle on multi select */
+  multi: PropTypes.bool.description('toggle on multi select'),
+
+  /** toggle on searchable behavior */
+  searchable: PropTypes.bool.description('toggle on searchable behavior'),
+
+  /** toggle to focus component on open */
+  focusOnOpen: PropTypes.bool.description('toggle to focus component on open'),
+
+  /** callback that triggers when select happens */
+  onSelect: PropTypes.func.description('callback that triggers when select happens'),
+  children: PropTypes.node.description(''),
+
+  /** selection group items  */
+  items: PropTypes.array.description('selection group items'),
+
+  /** array of values for multi and string for single selection */
+  active: PropTypes.oneOfType([PropTypes.string, PropTypes.array]).description('array of values for multi and string for single selection'),
+
+  /** selection group width */
+  width: PropTypes.number.description('selection group width'),
+
+  /** selection group height */
+  height: PropTypes.number.description('selection group height')
+};
+const DSMenuSelectionGroupWithSchema = describe(SelectionGroup);
+DSMenuSelectionGroupWithSchema.propTypes = props;
+
+export { DSMenuSelectionGroupWithSchema, SelectionGroup as default };

package/esm/MenuItems/Separator.js

@@ -0,0 +1,33 @@
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import { PropTypes, describe } from 'react-desc';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import DSSeparator from '@elliemae/ds-separator';
+import styled from 'styled-components';
+
+var _DSSeparator;
+const blockName = 'menu-separator';
+const Li = /*#__PURE__*/styled.li.withConfig({
+  componentId: "sc-aysbq3-0"
+})(["display:flex;align-items:flex-start;flex-direction:column;"]);
+const Title = aggregatedClasses('h5')(blockName, 'title');
+
+const MenuSeparator = _ref => {
+  let {
+    title,
+    showSeparator = true
+  } = _ref;
+  return /*#__PURE__*/_jsx(Li, {}, void 0, showSeparator && (_DSSeparator || (_DSSeparator = /*#__PURE__*/_jsx(DSSeparator, {}))), title && /*#__PURE__*/_jsx(Title, {}, void 0, title));
+};
+
+const props = {
+  /** menu separator h5 title */
+  title: PropTypes.string.description('menu separator h5 title'),
+
+  /** toggle separator on and off */
+  showSeparator: PropTypes.bool.description('toggle separator on and off')
+};
+const DSMenuSeparatorWithSchema = describe(MenuSeparator);
+DSMenuSeparatorWithSchema.propTypes = props;
+
+export { DSMenuSeparatorWithSchema, MenuSeparator as default };