@rescui/select 0.1.1

package/lib/state/multiselect/reducer.js

@@ -0,0 +1,203 @@
+import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
+import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
+import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
+import _toConsumableArray from "@babel/runtime-corejs3/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/esm/slicedToArray";
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
+import "core-js/modules/web.dom-collections.for-each.js";
+
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); if (enumerableOnly) { symbols = _filterInstanceProperty(symbols).call(symbols, 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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (_Object$getOwnPropertyDescriptors) { Object.defineProperties(target, _Object$getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { baseReducer } from '../select/reducer.js';
+import { setGroups, clearSelectedAndCloseMenu, closeMenu, openMenu } from '../select/actions.js';
+import { getDefaultCursorIndex, getOptionValue } from '../select/selectors.js';
+import { getGroups, isEmpty } from './selectors.js';
+import { setSelectedValue, setHideSelected, removeSelectedOption, removeSelectedIndex, addSelectedIndex } from './actions.js';
+
+function getInitialState(groups) {
+  var defaultSelected = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var hideSelected = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  return {
+    groups: groups,
+    menuIsOpen: false,
+    selected: defaultSelected,
+    searchString: '',
+    filteredGroups: null,
+    cursorIndex: getDefaultCursorIndex(groups),
+    hideSelected: hideSelected,
+    groupsWithoutSelected: groups
+  };
+}
+
+function handleOpenMenu(state) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    menuIsOpen: true
+  });
+}
+
+function handleCloseMenu(state) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    menuIsOpen: false
+  });
+}
+
+function clearSelection(state) {
+  var groups = getGroups(state);
+  return {
+    selected: null,
+    cursorIndex: getDefaultCursorIndex(groups),
+    menuIsOpen: false
+  };
+}
+
+function filterSelected(groups, selected) {
+  var selectedValues = {};
+
+  if (selected) {
+    selected.forEach(function (s) {
+      selectedValues[getOptionValue(s)] = true;
+    });
+  }
+
+  return _mapInstanceProperty(groups).call(groups, function (g) {
+    var newOptions = [];
+
+    if (g.options) {
+      var _context;
+
+      newOptions = _filterInstanceProperty(_context = g.options).call(_context, function (opt) {
+        return !selectedValues[getOptionValue(opt)];
+      });
+    }
+
+    return _objectSpread(_objectSpread({}, g), {}, {
+      options: newOptions
+    });
+  });
+}
+
+function addSelectedByIndex(state, index) {
+  var _context2;
+
+  var groups = getGroups(state);
+
+  var _index = _slicedToArray(index, 2),
+      grpIndex = _index[0],
+      optIndex = _index[1];
+
+  var selected = Array.isArray(state.selected) ? state.selected : [state.selected];
+  var selectedOption = groups[grpIndex].options[optIndex];
+  var newSelected = !state.selected ? [selectedOption] : _concatInstanceProperty(_context2 = []).call(_context2, _toConsumableArray(selected), [selectedOption]);
+  return {
+    selected: newSelected,
+    menuIsOpen: false,
+    searchString: '',
+    groupsWithoutSelected: filterSelected(state.groups, newSelected)
+  };
+}
+
+function removeSelected(state, option) {
+  var selected = Array.isArray(state.selected) ? state.selected : [state.selected];
+
+  var selectedWithoutOne = _filterInstanceProperty(selected).call(selected, function (o) {
+    return getOptionValue(o) !== getOptionValue(option);
+  });
+
+  return {
+    selected: selectedWithoutOne,
+    menuIsOpen: false,
+    searchString: '',
+    groupsWithoutSelected: filterSelected(state.groups, selectedWithoutOne)
+  };
+}
+
+function removeSelectedByIndex(state, index) {
+  var groups = getGroups(state);
+
+  var _index2 = _slicedToArray(index, 2),
+      grpIndex = _index2[0],
+      optIndex = _index2[1];
+
+  var unselectedOption = groups[grpIndex].options[optIndex];
+  return removeSelected(state, unselectedOption);
+}
+
+function handleToggleHideSelected(state, hideSelected) {
+  var result = {
+    hideSelected: hideSelected
+  };
+
+  if (hideSelected) {
+    var selected = Array.isArray(state.selected) ? state.selected : [state.selected];
+    result.groupsWithoutSelected = filterSelected(state.groups, selected);
+  }
+
+  return result;
+}
+
+function setSelectedControllable(state, selected) {
+  var result = {
+    selected: selected
+  };
+
+  if (state.hideSelected) {
+    result.groupsWithoutSelected = filterSelected(state.groups, selected);
+  }
+
+  return result;
+}
+
+function addDefaultCursorPosFromNewState(state) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    cursorIndex: getDefaultCursorIndex(getGroups(state))
+  });
+} // eslint-disable-next-line complexity
+
+
+function multiselectReducer(state, action) {
+  switch (action.type) {
+    case openMenu.type:
+      return _objectSpread(_objectSpread({}, state), handleOpenMenu(state));
+
+    case closeMenu.type:
+      return _objectSpread(_objectSpread({}, state), handleCloseMenu(state));
+
+    case addSelectedIndex.type:
+      return addDefaultCursorPosFromNewState(_objectSpread(_objectSpread({}, state), addSelectedByIndex(state, action.index)));
+
+    case removeSelectedIndex.type:
+      return addDefaultCursorPosFromNewState(_objectSpread(_objectSpread({}, state), removeSelectedByIndex(state, action.index)));
+
+    case removeSelectedOption.type:
+      return addDefaultCursorPosFromNewState(_objectSpread(_objectSpread({}, state), removeSelected(state, action.unselectedOption)));
+
+    case setHideSelected.type:
+      return addDefaultCursorPosFromNewState(_objectSpread(_objectSpread({}, state), handleToggleHideSelected(state, action.hideSelected)));
+
+    case clearSelectedAndCloseMenu.type:
+      return _objectSpread(_objectSpread(_objectSpread({}, state), clearSelection(state)), {}, {
+        groupsWithoutSelected: state.groups
+      });
+
+    case setGroups.type:
+      var selected = Array.isArray(state.selected) ? state.selected : [state.selected];
+      return _objectSpread({}, getInitialState(action.groups, selected, state.hideSelected));
+
+    case setSelectedValue.type:
+      return addDefaultCursorPosFromNewState(_objectSpread(_objectSpread({}, state), setSelectedControllable(state, action.selected)));
+
+    default:
+      return baseReducer(state, action, {
+        getGroups: getGroups,
+        isEmpty: isEmpty
+      });
+  }
+}
+
+export { getInitialState, multiselectReducer };

package/lib/state/multiselect/selectors.d.ts

@@ -0,0 +1,6 @@
+import { SelectOption, State } from '../../types';
+export declare const getGroups: (state: State) => import("../../types").Groups;
+export declare const isEmpty: (state: State) => boolean;
+export declare const getPlainOptions: (state: State) => any[];
+export declare const isSelected: (state: State, value: string) => boolean;
+export declare const getSelectedArray: (state: State) => SelectOption[];

package/lib/state/multiselect/selectors.js

@@ -0,0 +1,39 @@
+import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
+import { getPlainOptionsFromGroups, getOptionValue } from '../select/selectors.js';
+
+var getGroups = function getGroups(state) {
+  var groups = state.searchString && state.searchString !== '' ? state.filteredGroups : state.groups;
+  return state.hideSelected ? state.groupsWithoutSelected : groups;
+};
+
+var isEmpty = function isEmpty(state) {
+  var groups = getGroups(state);
+  return groups.length === 0 || groups.every(function (g) {
+    return g.options.length === 0;
+  });
+};
+
+var getPlainOptions = function getPlainOptions(state) {
+  return getPlainOptionsFromGroups(getGroups(state));
+};
+
+var isSelected = function isSelected(state, value) {
+  if (!state.selected) {
+    return false;
+  }
+
+  var selected = Array.isArray(state.selected) ? state.selected : [state.selected];
+  return Boolean(_findInstanceProperty(selected).call(selected, function (o) {
+    return getOptionValue(o) === value;
+  }));
+};
+
+var getSelectedArray = function getSelectedArray(state) {
+  if (!state.selected) {
+    return [];
+  }
+
+  return Array.isArray(state.selected) ? state.selected : [state.selected];
+};
+
+export { getGroups, getPlainOptions, getSelectedArray, isEmpty, isSelected };

package/lib/state/select/actions.d.ts

@@ -0,0 +1,81 @@
+import { Index, Groups, SelectOption, FilterFn } from '../../types';
+export declare function cursorMovedUp(): {
+    type: string;
+};
+export declare namespace cursorMovedUp {
+    var type: string;
+}
+export declare function cursorMovedDown(): {
+    type: string;
+};
+export declare namespace cursorMovedDown {
+    var type: string;
+}
+export declare function setCursorIndex(cursorIndex: Index): {
+    type: string;
+    cursorIndex: Index;
+};
+export declare namespace setCursorIndex {
+    var type: string;
+}
+export declare function setGroups(groups: Groups): {
+    type: string;
+    groups: Groups;
+};
+export declare namespace setGroups {
+    var type: string;
+}
+export declare function setSelectedValue(selected: SelectOption): {
+    type: string;
+    selected: SelectOption;
+};
+export declare namespace setSelectedValue {
+    var type: string;
+}
+export declare function setSelectedIndex(index: Index): {
+    type: string;
+    index: Index;
+};
+export declare namespace setSelectedIndex {
+    var type: string;
+}
+export declare function addSelectedIndex(index: Index): {
+    type: string;
+    index: Index;
+};
+export declare namespace addSelectedIndex {
+    var type: string;
+}
+export declare function removeSelectedIndex(index: Index): {
+    type: string;
+    index: Index;
+};
+export declare namespace removeSelectedIndex {
+    var type: string;
+}
+export declare function clearSelectedAndCloseMenu(): {
+    type: string;
+};
+export declare namespace clearSelectedAndCloseMenu {
+    var type: string;
+}
+export declare function setSearchString(searchString: string, filterFn?: FilterFn): {
+    type: string;
+    searchString: string;
+    filterFn: FilterFn;
+};
+export declare namespace setSearchString {
+    var type: string;
+}
+export declare function openMenu(): {
+    type: string;
+};
+export declare namespace openMenu {
+    var type: string;
+}
+export declare function closeMenu(): {
+    type: string;
+};
+export declare namespace closeMenu {
+    var type: string;
+}

package/lib/state/select/actions.js

@@ -0,0 +1,87 @@
+function cursorMovedUp() {
+  return {
+    type: cursorMovedUp.type
+  };
+}
+
+cursorMovedUp.type = 'STEP_UP';
+
+function cursorMovedDown() {
+  return {
+    type: cursorMovedDown.type
+  };
+}
+
+cursorMovedDown.type = 'STEP_DOWN';
+
+function setCursorIndex(cursorIndex) {
+  return {
+    type: setCursorIndex.type,
+    cursorIndex: cursorIndex
+  };
+}
+
+setCursorIndex.type = 'SET_CURSOR_INDEX';
+
+function setGroups(groups) {
+  return {
+    type: setGroups.type,
+    groups: groups
+  };
+}
+
+setGroups.type = 'SET_GROUPS';
+
+function setSelectedValue(selected) {
+  return {
+    type: setSelectedValue.type,
+    selected: selected
+  };
+}
+
+setSelectedValue.type = 'SET_SELECTED_VALUE';
+
+function setSelectedIndex(index) {
+  return {
+    type: setSelectedIndex.type,
+    index: index
+  };
+}
+
+setSelectedIndex.type = 'SET_SELECTED_BY_INDEX';
+
+function clearSelectedAndCloseMenu() {
+  return {
+    type: clearSelectedAndCloseMenu.type
+  };
+}
+
+clearSelectedAndCloseMenu.type = 'CLEAR_SELECTED_AND_CLOSE_MENU';
+
+function setSearchString(searchString) {
+  var filterFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return {
+    type: setSearchString.type,
+    searchString: searchString,
+    filterFn: filterFn
+  };
+}
+
+setSearchString.type = 'SET_SEARCH_STRING';
+
+function openMenu() {
+  return {
+    type: openMenu.type
+  };
+}
+
+openMenu.type = 'OPEN_MENU';
+
+function closeMenu() {
+  return {
+    type: closeMenu.type
+  };
+}
+
+closeMenu.type = 'CLOSE_MENU';
+export { clearSelectedAndCloseMenu, closeMenu, cursorMovedDown, cursorMovedUp, openMenu, setCursorIndex, setGroups, setSearchString, setSelectedIndex, setSelectedValue };

package/lib/state/select/reducer.d.ts

@@ -0,0 +1,22 @@
+import type { SelectOptionsGroup, SelectOption, Groups, State, Index, Action, SelectReducer } from '../../types';
+export declare function getInitialState(groups: SelectOptionsGroup[], defaultSelected?: SelectOption): State;
+export declare function baseReducer(state: State, action: Action, overrides?: {}): {
+    cursorIndex: any;
+    groups: Groups;
+    menuIsOpen: boolean;
+    selected: SelectOption | SelectOption[];
+    searchString: string;
+    filteredGroups: Groups;
+    hideSelected?: boolean;
+    groupsWithoutSelected?: Groups;
+} | {
+    selected: any;
+    groups: Groups;
+    menuIsOpen: boolean;
+    searchString: string;
+    filteredGroups: Groups;
+    cursorIndex: Index;
+    hideSelected?: boolean;
+    groupsWithoutSelected?: Groups;
+};
+export declare const selectReducer: SelectReducer;

package/lib/state/select/reducer.js

@@ -0,0 +1,199 @@
+import "core-js/modules/web.dom-collections.for-each.js";
+import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
+import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
+import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
+import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/esm/slicedToArray";
+import _mapInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/map";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
+
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); if (enumerableOnly) { symbols = _filterInstanceProperty(symbols).call(symbols, 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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (_Object$getOwnPropertyDescriptors) { Object.defineProperties(target, _Object$getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { setSelectedIndex, setSearchString, clearSelectedAndCloseMenu, setSelectedValue, setGroups, setCursorIndex, cursorMovedDown, cursorMovedUp, closeMenu, openMenu } from './actions.js';
+import { getDefaultCursorIndex, getGroups, isEmpty, getCursorIndex } from './selectors.js';
+
+function getInitialState(groups) {
+  var defaultSelected = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return {
+    groups: groups,
+    menuIsOpen: false,
+    selected: defaultSelected,
+    searchString: '',
+    filteredGroups: null,
+    cursorIndex: getDefaultCursorIndex(groups)
+  };
+}
+
+function setSelectedByIndex(state, index) {
+  var groups = getGroups(state);
+
+  var _index = _slicedToArray(index, 2),
+      grpIndex = _index[0],
+      optIndex = _index[1];
+
+  var selectedOption = groups[grpIndex].options[optIndex];
+  return {
+    selected: selectedOption,
+    cursorIndex: getDefaultCursorIndex(groups),
+    menuIsOpen: false,
+    searchString: ''
+  };
+}
+
+function clearSelection(state) {
+  var groups = getGroups(state);
+  return {
+    selected: null,
+    cursorIndex: getDefaultCursorIndex(groups),
+    menuIsOpen: false
+  };
+}
+
+function nextIndex(index, isDownDirection) {
+  return isDownDirection ? index + 1 : index - 1;
+}
+
+function isIndexOutOfRange(index, len) {
+  return index < 0 || index >= len;
+}
+
+function applySearchFilter(state, searchString, filterFn) {
+  if (searchString === '') {
+    var selected = Array.isArray(state.selected) ? state.selected[0] : state.selected;
+    return _objectSpread(_objectSpread({}, getInitialState(state.groups, selected)), {}, {
+      menuIsOpen: state.menuIsOpen
+    });
+  } else {
+    var _context;
+
+    var filteredGroups = _mapInstanceProperty(_context = state.groups).call(_context, function (g) {
+      var _context2;
+
+      return _objectSpread(_objectSpread({}, g), {}, {
+        options: _filterInstanceProperty(_context2 = g.options).call(_context2, filterFn)
+      });
+    });
+
+    return {
+      searchString: searchString,
+      filteredGroups: filteredGroups,
+      cursorIndex: getDefaultCursorIndex(filteredGroups),
+      menuIsOpen: true
+    };
+  }
+}
+
+function handleOpenMenu(state) {
+  return _objectSpread(_objectSpread({}, applySearchFilter(state, '')), {}, {
+    menuIsOpen: true
+  });
+}
+
+function handleCloseMenu(state) {
+  return _objectSpread(_objectSpread({}, applySearchFilter(state, '')), {}, {
+    menuIsOpen: false
+  });
+} // eslint-disable-next-line complexity
+
+
+function moveCursor(state, isDownDirection, overrides) {
+  var isGroupsEmpty = overrides.isEmpty ? overrides.isEmpty(state) : isEmpty(state);
+  if (isGroupsEmpty) return getCursorIndex(state);
+  var groups = overrides.getGroups ? overrides.getGroups(state) : getGroups(state);
+
+  var _getCursorIndex = getCursorIndex(state),
+      _getCursorIndex2 = _slicedToArray(_getCursorIndex, 2),
+      grpIndex = _getCursorIndex2[0],
+      optIndex = _getCursorIndex2[1];
+
+  var optLenByGroup = _mapInstanceProperty(groups).call(groups, function (g) {
+    return g.options ? g.options.length : 0;
+  });
+
+  var newGrpIndex = grpIndex;
+  var newOptIndex = nextIndex(optIndex, isDownDirection);
+
+  while (isIndexOutOfRange(newOptIndex, optLenByGroup[newGrpIndex]) || isIndexOutOfRange(newGrpIndex, groups.length)) {
+    newGrpIndex = nextIndex(newGrpIndex, isDownDirection);
+
+    if (isIndexOutOfRange(newGrpIndex, groups.length)) {
+      newGrpIndex = isDownDirection ? 0 : groups.length - 1;
+    }
+
+    newOptIndex = isDownDirection ? 0 : optLenByGroup[newGrpIndex] - 1;
+  }
+
+  return [newGrpIndex, newOptIndex];
+}
+
+function down(state, overrides) {
+  return moveCursor(state, true, overrides);
+}
+
+function up(state, overrides) {
+  return moveCursor(state, false, overrides);
+} // eslint-disable-next-line complexity
+
+
+function baseReducer(state, action) {
+  var overrides = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  switch (action.type) {
+    case openMenu.type:
+      return _objectSpread(_objectSpread({}, state), handleOpenMenu(state));
+
+    case closeMenu.type:
+      return _objectSpread(_objectSpread({}, state), handleCloseMenu(state));
+
+    case cursorMovedUp.type:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        cursorIndex: up(state, overrides)
+      });
+
+    case cursorMovedDown.type:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        cursorIndex: down(state, overrides)
+      });
+
+    case setCursorIndex.type:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        cursorIndex: action.cursorIndex
+      });
+
+    case setGroups.type:
+      var selected = Array.isArray(state.selected) ? state.selected[0] : state.selected;
+      return _objectSpread({}, getInitialState(action.groups, selected));
+
+    case setSelectedValue.type:
+      return action.selected !== undefined ? _objectSpread(_objectSpread({}, state), {}, {
+        selected: action.selected
+      }) : _objectSpread({}, state);
+
+    case setSelectedIndex.type:
+      return _objectSpread(_objectSpread({}, state), setSelectedByIndex(state, action.index));
+
+    case clearSelectedAndCloseMenu.type:
+      return _objectSpread(_objectSpread({}, state), clearSelection(state));
+
+    case setSearchString.type:
+      return _objectSpread(_objectSpread({}, state), applySearchFilter(state, action.searchString, action.filterFn));
+
+    default:
+      throw new Error('Unexpected action in Select/Multiselect component');
+  }
+}
+
+var selectReducer = function selectReducer(state, action) {
+  switch (action.type) {
+    case setSelectedIndex.type:
+      return _objectSpread(_objectSpread({}, state), setSelectedByIndex(state, action.index));
+
+    default:
+      return baseReducer(state, action);
+  }
+};
+
+export { baseReducer, getInitialState, selectReducer };

package/lib/state/select/selectors.d.ts

@@ -0,0 +1,20 @@
+import type { SelectOption, State, Index, Groups } from '../../types';
+export declare const getGroups: (state: State) => Groups;
+export declare const getCursorIndex: (state: State) => Index;
+export declare const isIndexMatchCursor: (state: State, index: Index) => boolean;
+export declare const isEmpty: (state: State) => boolean;
+export declare const withoutGroupsLabel: ({ groups }: {
+    groups: Groups;
+}) => boolean;
+export declare const OptionGroupTypes: {
+    HEADER: string;
+    OPTION: string;
+    DIVIDER: string;
+};
+export declare const getPlainOptionsFromGroups: (groups: Groups) => any[];
+export declare const getPlainOptions: (state: State) => any[];
+export declare function getOptionValue(option: SelectOption): string;
+export declare const getSelectedValue: (state: State) => string;
+export declare const getSelectedLabel: (state: State) => string;
+export declare const getSelected: (state: State) => SelectOption | SelectOption[];
+export declare const getDefaultCursorIndex: (groups: Groups) => Index;