react-select
Version:
A Select control built with and for ReactJS
1,429 lines (1,386 loc) • 96.5 kB
JavaScript
'use strict';
var _extends = require('@babel/runtime/helpers/extends');
var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
var _createClass = require('@babel/runtime/helpers/createClass');
var _inherits = require('@babel/runtime/helpers/inherits');
var _createSuper = require('@babel/runtime/helpers/createSuper');
var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
var React = require('react');
var index = require('./index-665c4ed8.cjs.prod.js');
var react = require('@emotion/react');
var memoizeOne = require('memoize-one');
var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var React__namespace = /*#__PURE__*/_interopNamespace(React);
var memoizeOne__default = /*#__PURE__*/_interopDefault(memoizeOne);
// Assistive text to describe visual elements. Hidden for sighted users.
var _ref = {
name: "7pg0cj-a11yText",
styles: "label:a11yText;z-index:9999;border:0;clip:rect(1px, 1px, 1px, 1px);height:1px;width:1px;position:absolute;overflow:hidden;padding:0;white-space:nowrap"
} ;
var A11yText = function A11yText(props) {
return react.jsx("span", _extends({
css: _ref
}, props));
};
var A11yText$1 = A11yText;
var defaultAriaLiveMessages = {
guidance: function guidance(props) {
var isSearchable = props.isSearchable,
isMulti = props.isMulti,
tabSelectsValue = props.tabSelectsValue,
context = props.context,
isInitialFocus = props.isInitialFocus;
switch (context) {
case 'menu':
return "Use Up and Down to choose options, press Enter to select the currently focused option, press Escape to exit the menu".concat(tabSelectsValue ? ', press Tab to select the option and exit the menu' : '', ".");
case 'input':
return isInitialFocus ? "".concat(props['aria-label'] || 'Select', " is focused ").concat(isSearchable ? ',type to refine list' : '', ", press Down to open the menu, ").concat(isMulti ? ' press left to focus selected values' : '') : '';
case 'value':
return 'Use left and right to toggle between focused values, press Backspace to remove the currently focused value';
default:
return '';
}
},
onChange: function onChange(props) {
var action = props.action,
_props$label = props.label,
label = _props$label === void 0 ? '' : _props$label,
labels = props.labels,
isDisabled = props.isDisabled;
switch (action) {
case 'deselect-option':
case 'pop-value':
case 'remove-value':
return "option ".concat(label, ", deselected.");
case 'clear':
return 'All selected options have been cleared.';
case 'initial-input-focus':
return "option".concat(labels.length > 1 ? 's' : '', " ").concat(labels.join(','), ", selected.");
case 'select-option':
return isDisabled ? "option ".concat(label, " is disabled. Select another option.") : "option ".concat(label, ", selected.");
default:
return '';
}
},
onFocus: function onFocus(props) {
var context = props.context,
focused = props.focused,
options = props.options,
_props$label2 = props.label,
label = _props$label2 === void 0 ? '' : _props$label2,
selectValue = props.selectValue,
isDisabled = props.isDisabled,
isSelected = props.isSelected,
isAppleDevice = props.isAppleDevice;
var getArrayIndex = function getArrayIndex(arr, item) {
return arr && arr.length ? "".concat(arr.indexOf(item) + 1, " of ").concat(arr.length) : '';
};
if (context === 'value' && selectValue) {
return "value ".concat(label, " focused, ").concat(getArrayIndex(selectValue, focused), ".");
}
if (context === 'menu' && isAppleDevice) {
var disabled = isDisabled ? ' disabled' : '';
var status = "".concat(isSelected ? ' selected' : '').concat(disabled);
return "".concat(label).concat(status, ", ").concat(getArrayIndex(options, focused), ".");
}
return '';
},
onFilter: function onFilter(props) {
var inputValue = props.inputValue,
resultsMessage = props.resultsMessage;
return "".concat(resultsMessage).concat(inputValue ? ' for search term ' + inputValue : '', ".");
}
};
var LiveRegion = function LiveRegion(props) {
var ariaSelection = props.ariaSelection,
focusedOption = props.focusedOption,
focusedValue = props.focusedValue,
focusableOptions = props.focusableOptions,
isFocused = props.isFocused,
selectValue = props.selectValue,
selectProps = props.selectProps,
id = props.id,
isAppleDevice = props.isAppleDevice;
var ariaLiveMessages = selectProps.ariaLiveMessages,
getOptionLabel = selectProps.getOptionLabel,
inputValue = selectProps.inputValue,
isMulti = selectProps.isMulti,
isOptionDisabled = selectProps.isOptionDisabled,
isSearchable = selectProps.isSearchable,
menuIsOpen = selectProps.menuIsOpen,
options = selectProps.options,
screenReaderStatus = selectProps.screenReaderStatus,
tabSelectsValue = selectProps.tabSelectsValue,
isLoading = selectProps.isLoading;
var ariaLabel = selectProps['aria-label'];
var ariaLive = selectProps['aria-live'];
// Update aria live message configuration when prop changes
var messages = React.useMemo(function () {
return _objectSpread(_objectSpread({}, defaultAriaLiveMessages), ariaLiveMessages || {});
}, [ariaLiveMessages]);
// Update aria live selected option when prop changes
var ariaSelected = React.useMemo(function () {
var message = '';
if (ariaSelection && messages.onChange) {
var option = ariaSelection.option,
selectedOptions = ariaSelection.options,
removedValue = ariaSelection.removedValue,
removedValues = ariaSelection.removedValues,
value = ariaSelection.value;
// select-option when !isMulti does not return option so we assume selected option is value
var asOption = function asOption(val) {
return !Array.isArray(val) ? val : null;
};
// If there is just one item from the action then get its label
var selected = removedValue || option || asOption(value);
var label = selected ? getOptionLabel(selected) : '';
// If there are multiple items from the action then return an array of labels
var multiSelected = selectedOptions || removedValues || undefined;
var labels = multiSelected ? multiSelected.map(getOptionLabel) : [];
var onChangeProps = _objectSpread({
// multiSelected items are usually items that have already been selected
// or set by the user as a default value so we assume they are not disabled
isDisabled: selected && isOptionDisabled(selected, selectValue),
label: label,
labels: labels
}, ariaSelection);
message = messages.onChange(onChangeProps);
}
return message;
}, [ariaSelection, messages, isOptionDisabled, selectValue, getOptionLabel]);
var ariaFocused = React.useMemo(function () {
var focusMsg = '';
var focused = focusedOption || focusedValue;
var isSelected = !!(focusedOption && selectValue && selectValue.includes(focusedOption));
if (focused && messages.onFocus) {
var onFocusProps = {
focused: focused,
label: getOptionLabel(focused),
isDisabled: isOptionDisabled(focused, selectValue),
isSelected: isSelected,
options: focusableOptions,
context: focused === focusedOption ? 'menu' : 'value',
selectValue: selectValue,
isAppleDevice: isAppleDevice
};
focusMsg = messages.onFocus(onFocusProps);
}
return focusMsg;
}, [focusedOption, focusedValue, getOptionLabel, isOptionDisabled, messages, focusableOptions, selectValue, isAppleDevice]);
var ariaResults = React.useMemo(function () {
var resultsMsg = '';
if (menuIsOpen && options.length && !isLoading && messages.onFilter) {
var resultsMessage = screenReaderStatus({
count: focusableOptions.length
});
resultsMsg = messages.onFilter({
inputValue: inputValue,
resultsMessage: resultsMessage
});
}
return resultsMsg;
}, [focusableOptions, inputValue, menuIsOpen, messages, options, screenReaderStatus, isLoading]);
var isInitialFocus = (ariaSelection === null || ariaSelection === void 0 ? void 0 : ariaSelection.action) === 'initial-input-focus';
var ariaGuidance = React.useMemo(function () {
var guidanceMsg = '';
if (messages.guidance) {
var context = focusedValue ? 'value' : menuIsOpen ? 'menu' : 'input';
guidanceMsg = messages.guidance({
'aria-label': ariaLabel,
context: context,
isDisabled: focusedOption && isOptionDisabled(focusedOption, selectValue),
isMulti: isMulti,
isSearchable: isSearchable,
tabSelectsValue: tabSelectsValue,
isInitialFocus: isInitialFocus
});
}
return guidanceMsg;
}, [ariaLabel, focusedOption, focusedValue, isMulti, isOptionDisabled, isSearchable, menuIsOpen, messages, selectValue, tabSelectsValue, isInitialFocus]);
var ScreenReaderText = react.jsx(React.Fragment, null, react.jsx("span", {
id: "aria-selection"
}, ariaSelected), react.jsx("span", {
id: "aria-focused"
}, ariaFocused), react.jsx("span", {
id: "aria-results"
}, ariaResults), react.jsx("span", {
id: "aria-guidance"
}, ariaGuidance));
return react.jsx(React.Fragment, null, react.jsx(A11yText$1, {
id: id
}, isInitialFocus && ScreenReaderText), react.jsx(A11yText$1, {
"aria-live": ariaLive,
"aria-atomic": "false",
"aria-relevant": "additions text",
role: "log"
}, isFocused && !isInitialFocus && ScreenReaderText));
};
var LiveRegion$1 = LiveRegion;
var diacritics = [{
base: 'A',
letters: "A\u24B6\uFF21\xC0\xC1\xC2\u1EA6\u1EA4\u1EAA\u1EA8\xC3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\xC4\u01DE\u1EA2\xC5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F"
}, {
base: 'AA',
letters: "\uA732"
}, {
base: 'AE',
letters: "\xC6\u01FC\u01E2"
}, {
base: 'AO',
letters: "\uA734"
}, {
base: 'AU',
letters: "\uA736"
}, {
base: 'AV',
letters: "\uA738\uA73A"
}, {
base: 'AY',
letters: "\uA73C"
}, {
base: 'B',
letters: "B\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181"
}, {
base: 'C',
letters: "C\u24B8\uFF23\u0106\u0108\u010A\u010C\xC7\u1E08\u0187\u023B\uA73E"
}, {
base: 'D',
letters: "D\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779"
}, {
base: 'DZ',
letters: "\u01F1\u01C4"
}, {
base: 'Dz',
letters: "\u01F2\u01C5"
}, {
base: 'E',
letters: "E\u24BA\uFF25\xC8\xC9\xCA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\xCB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E"
}, {
base: 'F',
letters: "F\u24BB\uFF26\u1E1E\u0191\uA77B"
}, {
base: 'G',
letters: "G\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E"
}, {
base: 'H',
letters: "H\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D"
}, {
base: 'I',
letters: "I\u24BE\uFF29\xCC\xCD\xCE\u0128\u012A\u012C\u0130\xCF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197"
}, {
base: 'J',
letters: "J\u24BF\uFF2A\u0134\u0248"
}, {
base: 'K',
letters: "K\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2"
}, {
base: 'L',
letters: "L\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780"
}, {
base: 'LJ',
letters: "\u01C7"
}, {
base: 'Lj',
letters: "\u01C8"
}, {
base: 'M',
letters: "M\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C"
}, {
base: 'N',
letters: "N\u24C3\uFF2E\u01F8\u0143\xD1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4"
}, {
base: 'NJ',
letters: "\u01CA"
}, {
base: 'Nj',
letters: "\u01CB"
}, {
base: 'O',
letters: "O\u24C4\uFF2F\xD2\xD3\xD4\u1ED2\u1ED0\u1ED6\u1ED4\xD5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\xD6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\xD8\u01FE\u0186\u019F\uA74A\uA74C"
}, {
base: 'OI',
letters: "\u01A2"
}, {
base: 'OO',
letters: "\uA74E"
}, {
base: 'OU',
letters: "\u0222"
}, {
base: 'P',
letters: "P\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754"
}, {
base: 'Q',
letters: "Q\u24C6\uFF31\uA756\uA758\u024A"
}, {
base: 'R',
letters: "R\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782"
}, {
base: 'S',
letters: "S\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784"
}, {
base: 'T',
letters: "T\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786"
}, {
base: 'TZ',
letters: "\uA728"
}, {
base: 'U',
letters: "U\u24CA\uFF35\xD9\xDA\xDB\u0168\u1E78\u016A\u1E7A\u016C\xDC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244"
}, {
base: 'V',
letters: "V\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245"
}, {
base: 'VY',
letters: "\uA760"
}, {
base: 'W',
letters: "W\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72"
}, {
base: 'X',
letters: "X\u24CD\uFF38\u1E8A\u1E8C"
}, {
base: 'Y',
letters: "Y\u24CE\uFF39\u1EF2\xDD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE"
}, {
base: 'Z',
letters: "Z\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762"
}, {
base: 'a',
letters: "a\u24D0\uFF41\u1E9A\xE0\xE1\xE2\u1EA7\u1EA5\u1EAB\u1EA9\xE3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\xE4\u01DF\u1EA3\xE5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250"
}, {
base: 'aa',
letters: "\uA733"
}, {
base: 'ae',
letters: "\xE6\u01FD\u01E3"
}, {
base: 'ao',
letters: "\uA735"
}, {
base: 'au',
letters: "\uA737"
}, {
base: 'av',
letters: "\uA739\uA73B"
}, {
base: 'ay',
letters: "\uA73D"
}, {
base: 'b',
letters: "b\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253"
}, {
base: 'c',
letters: "c\u24D2\uFF43\u0107\u0109\u010B\u010D\xE7\u1E09\u0188\u023C\uA73F\u2184"
}, {
base: 'd',
letters: "d\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A"
}, {
base: 'dz',
letters: "\u01F3\u01C6"
}, {
base: 'e',
letters: "e\u24D4\uFF45\xE8\xE9\xEA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\xEB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD"
}, {
base: 'f',
letters: "f\u24D5\uFF46\u1E1F\u0192\uA77C"
}, {
base: 'g',
letters: "g\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F"
}, {
base: 'h',
letters: "h\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265"
}, {
base: 'hv',
letters: "\u0195"
}, {
base: 'i',
letters: "i\u24D8\uFF49\xEC\xED\xEE\u0129\u012B\u012D\xEF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131"
}, {
base: 'j',
letters: "j\u24D9\uFF4A\u0135\u01F0\u0249"
}, {
base: 'k',
letters: "k\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3"
}, {
base: 'l',
letters: "l\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747"
}, {
base: 'lj',
letters: "\u01C9"
}, {
base: 'm',
letters: "m\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F"
}, {
base: 'n',
letters: "n\u24DD\uFF4E\u01F9\u0144\xF1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5"
}, {
base: 'nj',
letters: "\u01CC"
}, {
base: 'o',
letters: "o\u24DE\uFF4F\xF2\xF3\xF4\u1ED3\u1ED1\u1ED7\u1ED5\xF5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\xF6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\xF8\u01FF\u0254\uA74B\uA74D\u0275"
}, {
base: 'oi',
letters: "\u01A3"
}, {
base: 'ou',
letters: "\u0223"
}, {
base: 'oo',
letters: "\uA74F"
}, {
base: 'p',
letters: "p\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755"
}, {
base: 'q',
letters: "q\u24E0\uFF51\u024B\uA757\uA759"
}, {
base: 'r',
letters: "r\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783"
}, {
base: 's',
letters: "s\u24E2\uFF53\xDF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B"
}, {
base: 't',
letters: "t\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787"
}, {
base: 'tz',
letters: "\uA729"
}, {
base: 'u',
letters: "u\u24E4\uFF55\xF9\xFA\xFB\u0169\u1E79\u016B\u1E7B\u016D\xFC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289"
}, {
base: 'v',
letters: "v\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C"
}, {
base: 'vy',
letters: "\uA761"
}, {
base: 'w',
letters: "w\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73"
}, {
base: 'x',
letters: "x\u24E7\uFF58\u1E8B\u1E8D"
}, {
base: 'y',
letters: "y\u24E8\uFF59\u1EF3\xFD\u0177\u1EF9\u0233\u1E8F\xFF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF"
}, {
base: 'z',
letters: "z\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763"
}];
var anyDiacritic = new RegExp('[' + diacritics.map(function (d) {
return d.letters;
}).join('') + ']', 'g');
var diacriticToBase = {};
for (var i = 0; i < diacritics.length; i++) {
var diacritic = diacritics[i];
for (var j = 0; j < diacritic.letters.length; j++) {
diacriticToBase[diacritic.letters[j]] = diacritic.base;
}
}
var stripDiacritics = function stripDiacritics(str) {
return str.replace(anyDiacritic, function (match) {
return diacriticToBase[match];
});
};
var memoizedStripDiacriticsForInput = memoizeOne__default["default"](stripDiacritics);
var trimString = function trimString(str) {
return str.replace(/^\s+|\s+$/g, '');
};
var defaultStringify = function defaultStringify(option) {
return "".concat(option.label, " ").concat(option.value);
};
var createFilter = function createFilter(config) {
return function (option, rawInput) {
// eslint-disable-next-line no-underscore-dangle
if (option.data.__isNew__) return true;
var _ignoreCase$ignoreAcc = _objectSpread({
ignoreCase: true,
ignoreAccents: true,
stringify: defaultStringify,
trim: true,
matchFrom: 'any'
}, config),
ignoreCase = _ignoreCase$ignoreAcc.ignoreCase,
ignoreAccents = _ignoreCase$ignoreAcc.ignoreAccents,
stringify = _ignoreCase$ignoreAcc.stringify,
trim = _ignoreCase$ignoreAcc.trim,
matchFrom = _ignoreCase$ignoreAcc.matchFrom;
var input = trim ? trimString(rawInput) : rawInput;
var candidate = trim ? trimString(stringify(option)) : stringify(option);
if (ignoreCase) {
input = input.toLowerCase();
candidate = candidate.toLowerCase();
}
if (ignoreAccents) {
input = memoizedStripDiacriticsForInput(input);
candidate = stripDiacritics(candidate);
}
return matchFrom === 'start' ? candidate.substr(0, input.length) === input : candidate.indexOf(input) > -1;
};
};
var _excluded = ["innerRef"];
function DummyInput(_ref) {
var innerRef = _ref.innerRef,
props = _objectWithoutProperties(_ref, _excluded);
// Remove animation props not meant for HTML elements
var filteredProps = index.removeProps(props, 'onExited', 'in', 'enter', 'exit', 'appear');
return react.jsx("input", _extends({
ref: innerRef
}, filteredProps, {
css: /*#__PURE__*/react.css({
label: 'dummyInput',
// get rid of any default styles
background: 0,
border: 0,
// important! this hides the flashing cursor
caretColor: 'transparent',
fontSize: 'inherit',
gridArea: '1 / 1 / 2 / 3',
outline: 0,
padding: 0,
// important! without `width` browsers won't allow focus
width: 1,
// remove cursor on desktop
color: 'transparent',
// remove cursor on mobile whilst maintaining "scroll into view" behaviour
left: -100,
opacity: 0,
position: 'relative',
transform: 'scale(.01)'
}, "" , "" )
}));
}
var cancelScroll = function cancelScroll(event) {
if (event.cancelable) event.preventDefault();
event.stopPropagation();
};
function useScrollCapture(_ref) {
var isEnabled = _ref.isEnabled,
onBottomArrive = _ref.onBottomArrive,
onBottomLeave = _ref.onBottomLeave,
onTopArrive = _ref.onTopArrive,
onTopLeave = _ref.onTopLeave;
var isBottom = React.useRef(false);
var isTop = React.useRef(false);
var touchStart = React.useRef(0);
var scrollTarget = React.useRef(null);
var handleEventDelta = React.useCallback(function (event, delta) {
if (scrollTarget.current === null) return;
var _scrollTarget$current = scrollTarget.current,
scrollTop = _scrollTarget$current.scrollTop,
scrollHeight = _scrollTarget$current.scrollHeight,
clientHeight = _scrollTarget$current.clientHeight;
var target = scrollTarget.current;
var isDeltaPositive = delta > 0;
var availableScroll = scrollHeight - clientHeight - scrollTop;
var shouldCancelScroll = false;
// reset bottom/top flags
if (availableScroll > delta && isBottom.current) {
if (onBottomLeave) onBottomLeave(event);
isBottom.current = false;
}
if (isDeltaPositive && isTop.current) {
if (onTopLeave) onTopLeave(event);
isTop.current = false;
}
// bottom limit
if (isDeltaPositive && delta > availableScroll) {
if (onBottomArrive && !isBottom.current) {
onBottomArrive(event);
}
target.scrollTop = scrollHeight;
shouldCancelScroll = true;
isBottom.current = true;
// top limit
} else if (!isDeltaPositive && -delta > scrollTop) {
if (onTopArrive && !isTop.current) {
onTopArrive(event);
}
target.scrollTop = 0;
shouldCancelScroll = true;
isTop.current = true;
}
// cancel scroll
if (shouldCancelScroll) {
cancelScroll(event);
}
}, [onBottomArrive, onBottomLeave, onTopArrive, onTopLeave]);
var onWheel = React.useCallback(function (event) {
handleEventDelta(event, event.deltaY);
}, [handleEventDelta]);
var onTouchStart = React.useCallback(function (event) {
// set touch start so we can calculate touchmove delta
touchStart.current = event.changedTouches[0].clientY;
}, []);
var onTouchMove = React.useCallback(function (event) {
var deltaY = touchStart.current - event.changedTouches[0].clientY;
handleEventDelta(event, deltaY);
}, [handleEventDelta]);
var startListening = React.useCallback(function (el) {
// bail early if no element is available to attach to
if (!el) return;
var notPassive = index.supportsPassiveEvents ? {
passive: false
} : false;
el.addEventListener('wheel', onWheel, notPassive);
el.addEventListener('touchstart', onTouchStart, notPassive);
el.addEventListener('touchmove', onTouchMove, notPassive);
}, [onTouchMove, onTouchStart, onWheel]);
var stopListening = React.useCallback(function (el) {
// bail early if no element is available to detach from
if (!el) return;
el.removeEventListener('wheel', onWheel, false);
el.removeEventListener('touchstart', onTouchStart, false);
el.removeEventListener('touchmove', onTouchMove, false);
}, [onTouchMove, onTouchStart, onWheel]);
React.useEffect(function () {
if (!isEnabled) return;
var element = scrollTarget.current;
startListening(element);
return function () {
stopListening(element);
};
}, [isEnabled, startListening, stopListening]);
return function (element) {
scrollTarget.current = element;
};
}
var STYLE_KEYS = ['boxSizing', 'height', 'overflow', 'paddingRight', 'position'];
var LOCK_STYLES = {
boxSizing: 'border-box',
// account for possible declaration `width: 100%;` on body
overflow: 'hidden',
position: 'relative',
height: '100%'
};
function preventTouchMove(e) {
e.preventDefault();
}
function allowTouchMove(e) {
e.stopPropagation();
}
function preventInertiaScroll() {
var top = this.scrollTop;
var totalScroll = this.scrollHeight;
var currentScroll = top + this.offsetHeight;
if (top === 0) {
this.scrollTop = 1;
} else if (currentScroll === totalScroll) {
this.scrollTop = top - 1;
}
}
// `ontouchstart` check works on most browsers
// `maxTouchPoints` works on IE10/11 and Surface
function isTouchDevice() {
return 'ontouchstart' in window || navigator.maxTouchPoints;
}
var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
var activeScrollLocks = 0;
var listenerOptions = {
capture: false,
passive: false
};
function useScrollLock(_ref) {
var isEnabled = _ref.isEnabled,
_ref$accountForScroll = _ref.accountForScrollbars,
accountForScrollbars = _ref$accountForScroll === void 0 ? true : _ref$accountForScroll;
var originalStyles = React.useRef({});
var scrollTarget = React.useRef(null);
var addScrollLock = React.useCallback(function (touchScrollTarget) {
if (!canUseDOM) return;
var target = document.body;
var targetStyle = target && target.style;
if (accountForScrollbars) {
// store any styles already applied to the body
STYLE_KEYS.forEach(function (key) {
var val = targetStyle && targetStyle[key];
originalStyles.current[key] = val;
});
}
// apply the lock styles and padding if this is the first scroll lock
if (accountForScrollbars && activeScrollLocks < 1) {
var currentPadding = parseInt(originalStyles.current.paddingRight, 10) || 0;
var clientWidth = document.body ? document.body.clientWidth : 0;
var adjustedPadding = window.innerWidth - clientWidth + currentPadding || 0;
Object.keys(LOCK_STYLES).forEach(function (key) {
var val = LOCK_STYLES[key];
if (targetStyle) {
targetStyle[key] = val;
}
});
if (targetStyle) {
targetStyle.paddingRight = "".concat(adjustedPadding, "px");
}
}
// account for touch devices
if (target && isTouchDevice()) {
// Mobile Safari ignores { overflow: hidden } declaration on the body.
target.addEventListener('touchmove', preventTouchMove, listenerOptions);
// Allow scroll on provided target
if (touchScrollTarget) {
touchScrollTarget.addEventListener('touchstart', preventInertiaScroll, listenerOptions);
touchScrollTarget.addEventListener('touchmove', allowTouchMove, listenerOptions);
}
}
// increment active scroll locks
activeScrollLocks += 1;
}, [accountForScrollbars]);
var removeScrollLock = React.useCallback(function (touchScrollTarget) {
if (!canUseDOM) return;
var target = document.body;
var targetStyle = target && target.style;
// safely decrement active scroll locks
activeScrollLocks = Math.max(activeScrollLocks - 1, 0);
// reapply original body styles, if any
if (accountForScrollbars && activeScrollLocks < 1) {
STYLE_KEYS.forEach(function (key) {
var val = originalStyles.current[key];
if (targetStyle) {
targetStyle[key] = val;
}
});
}
// remove touch listeners
if (target && isTouchDevice()) {
target.removeEventListener('touchmove', preventTouchMove, listenerOptions);
if (touchScrollTarget) {
touchScrollTarget.removeEventListener('touchstart', preventInertiaScroll, listenerOptions);
touchScrollTarget.removeEventListener('touchmove', allowTouchMove, listenerOptions);
}
}
}, [accountForScrollbars]);
React.useEffect(function () {
if (!isEnabled) return;
var element = scrollTarget.current;
addScrollLock(element);
return function () {
removeScrollLock(element);
};
}, [isEnabled, addScrollLock, removeScrollLock]);
return function (element) {
scrollTarget.current = element;
};
}
var blurSelectInput = function blurSelectInput(event) {
var element = event.target;
return element.ownerDocument.activeElement && element.ownerDocument.activeElement.blur();
};
var _ref2$1 = {
name: "1kfdb0e",
styles: "position:fixed;left:0;bottom:0;right:0;top:0"
} ;
function ScrollManager(_ref) {
var children = _ref.children,
lockEnabled = _ref.lockEnabled,
_ref$captureEnabled = _ref.captureEnabled,
captureEnabled = _ref$captureEnabled === void 0 ? true : _ref$captureEnabled,
onBottomArrive = _ref.onBottomArrive,
onBottomLeave = _ref.onBottomLeave,
onTopArrive = _ref.onTopArrive,
onTopLeave = _ref.onTopLeave;
var setScrollCaptureTarget = useScrollCapture({
isEnabled: captureEnabled,
onBottomArrive: onBottomArrive,
onBottomLeave: onBottomLeave,
onTopArrive: onTopArrive,
onTopLeave: onTopLeave
});
var setScrollLockTarget = useScrollLock({
isEnabled: lockEnabled
});
var targetRef = function targetRef(element) {
setScrollCaptureTarget(element);
setScrollLockTarget(element);
};
return react.jsx(React.Fragment, null, lockEnabled && react.jsx("div", {
onClick: blurSelectInput,
css: _ref2$1
}), children(targetRef));
}
var _ref2 = {
name: "1a0ro4n-requiredInput",
styles: "label:requiredInput;opacity:0;pointer-events:none;position:absolute;bottom:0;left:0;right:0;width:100%"
} ;
var RequiredInput = function RequiredInput(_ref) {
var name = _ref.name,
onFocus = _ref.onFocus;
return react.jsx("input", {
required: true,
name: name,
tabIndex: -1,
"aria-hidden": "true",
onFocus: onFocus,
css: _ref2
// Prevent `Switching from uncontrolled to controlled` error
,
value: "",
onChange: function onChange() {}
});
};
var RequiredInput$1 = RequiredInput;
/// <reference types="user-agent-data-types" />
function testPlatform(re) {
var _window$navigator$use;
return typeof window !== 'undefined' && window.navigator != null ? re.test(((_window$navigator$use = window.navigator['userAgentData']) === null || _window$navigator$use === void 0 ? void 0 : _window$navigator$use.platform) || window.navigator.platform) : false;
}
function isIPhone() {
return testPlatform(/^iPhone/i);
}
function isMac() {
return testPlatform(/^Mac/i);
}
function isIPad() {
return testPlatform(/^iPad/i) ||
// iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
isMac() && navigator.maxTouchPoints > 1;
}
function isIOS() {
return isIPhone() || isIPad();
}
function isAppleDevice() {
return isMac() || isIOS();
}
var formatGroupLabel = function formatGroupLabel(group) {
return group.label;
};
var getOptionLabel$1 = function getOptionLabel(option) {
return option.label;
};
var getOptionValue$1 = function getOptionValue(option) {
return option.value;
};
var isOptionDisabled = function isOptionDisabled(option) {
return !!option.isDisabled;
};
var defaultStyles = {
clearIndicator: index.clearIndicatorCSS,
container: index.containerCSS,
control: index.css,
dropdownIndicator: index.dropdownIndicatorCSS,
group: index.groupCSS,
groupHeading: index.groupHeadingCSS,
indicatorsContainer: index.indicatorsContainerCSS,
indicatorSeparator: index.indicatorSeparatorCSS,
input: index.inputCSS,
loadingIndicator: index.loadingIndicatorCSS,
loadingMessage: index.loadingMessageCSS,
menu: index.menuCSS,
menuList: index.menuListCSS,
menuPortal: index.menuPortalCSS,
multiValue: index.multiValueCSS,
multiValueLabel: index.multiValueLabelCSS,
multiValueRemove: index.multiValueRemoveCSS,
noOptionsMessage: index.noOptionsMessageCSS,
option: index.optionCSS,
placeholder: index.placeholderCSS,
singleValue: index.css$1,
valueContainer: index.valueContainerCSS
};
// Merge Utility
// Allows consumers to extend a base Select with additional styles
function mergeStyles(source) {
var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
// initialize with source styles
var styles = _objectSpread({}, source);
// massage in target styles
Object.keys(target).forEach(function (keyAsString) {
var key = keyAsString;
if (source[key]) {
styles[key] = function (rsCss, props) {
return target[key](source[key](rsCss, props), props);
};
} else {
styles[key] = target[key];
}
});
return styles;
}
var colors = {
primary: '#2684FF',
primary75: '#4C9AFF',
primary50: '#B2D4FF',
primary25: '#DEEBFF',
danger: '#DE350B',
dangerLight: '#FFBDAD',
neutral0: 'hsl(0, 0%, 100%)',
neutral5: 'hsl(0, 0%, 95%)',
neutral10: 'hsl(0, 0%, 90%)',
neutral20: 'hsl(0, 0%, 80%)',
neutral30: 'hsl(0, 0%, 70%)',
neutral40: 'hsl(0, 0%, 60%)',
neutral50: 'hsl(0, 0%, 50%)',
neutral60: 'hsl(0, 0%, 40%)',
neutral70: 'hsl(0, 0%, 30%)',
neutral80: 'hsl(0, 0%, 20%)',
neutral90: 'hsl(0, 0%, 10%)'
};
var borderRadius = 4;
// Used to calculate consistent margin/padding on elements
var baseUnit = 4;
// The minimum height of the control
var controlHeight = 38;
// The amount of space between the control and menu */
var menuGutter = baseUnit * 2;
var spacing = {
baseUnit: baseUnit,
controlHeight: controlHeight,
menuGutter: menuGutter
};
var defaultTheme = {
borderRadius: borderRadius,
colors: colors,
spacing: spacing
};
var defaultProps = {
'aria-live': 'polite',
backspaceRemovesValue: true,
blurInputOnSelect: index.isTouchCapable(),
captureMenuScroll: !index.isTouchCapable(),
classNames: {},
closeMenuOnSelect: true,
closeMenuOnScroll: false,
components: {},
controlShouldRenderValue: true,
escapeClearsValue: false,
filterOption: createFilter(),
formatGroupLabel: formatGroupLabel,
getOptionLabel: getOptionLabel$1,
getOptionValue: getOptionValue$1,
isDisabled: false,
isLoading: false,
isMulti: false,
isRtl: false,
isSearchable: true,
isOptionDisabled: isOptionDisabled,
loadingMessage: function loadingMessage() {
return 'Loading...';
},
maxMenuHeight: 300,
minMenuHeight: 140,
menuIsOpen: false,
menuPlacement: 'bottom',
menuPosition: 'absolute',
menuShouldBlockScroll: false,
menuShouldScrollIntoView: !index.isMobileDevice(),
noOptionsMessage: function noOptionsMessage() {
return 'No options';
},
openMenuOnFocus: false,
openMenuOnClick: true,
options: [],
pageSize: 5,
placeholder: 'Select...',
screenReaderStatus: function screenReaderStatus(_ref) {
var count = _ref.count;
return "".concat(count, " result").concat(count !== 1 ? 's' : '', " available");
},
styles: {},
tabIndex: 0,
tabSelectsValue: true,
unstyled: false
};
function toCategorizedOption(props, option, selectValue, index) {
var isDisabled = _isOptionDisabled(props, option, selectValue);
var isSelected = _isOptionSelected(props, option, selectValue);
var label = getOptionLabel(props, option);
var value = getOptionValue(props, option);
return {
type: 'option',
data: option,
isDisabled: isDisabled,
isSelected: isSelected,
label: label,
value: value,
index: index
};
}
function buildCategorizedOptions(props, selectValue) {
return props.options.map(function (groupOrOption, groupOrOptionIndex) {
if ('options' in groupOrOption) {
var categorizedOptions = groupOrOption.options.map(function (option, optionIndex) {
return toCategorizedOption(props, option, selectValue, optionIndex);
}).filter(function (categorizedOption) {
return isFocusable(props, categorizedOption);
});
return categorizedOptions.length > 0 ? {
type: 'group',
data: groupOrOption,
options: categorizedOptions,
index: groupOrOptionIndex
} : undefined;
}
var categorizedOption = toCategorizedOption(props, groupOrOption, selectValue, groupOrOptionIndex);
return isFocusable(props, categorizedOption) ? categorizedOption : undefined;
}).filter(index.notNullish);
}
function buildFocusableOptionsFromCategorizedOptions(categorizedOptions) {
return categorizedOptions.reduce(function (optionsAccumulator, categorizedOption) {
if (categorizedOption.type === 'group') {
optionsAccumulator.push.apply(optionsAccumulator, _toConsumableArray(categorizedOption.options.map(function (option) {
return option.data;
})));
} else {
optionsAccumulator.push(categorizedOption.data);
}
return optionsAccumulator;
}, []);
}
function buildFocusableOptionsWithIds(categorizedOptions, optionId) {
return categorizedOptions.reduce(function (optionsAccumulator, categorizedOption) {
if (categorizedOption.type === 'group') {
optionsAccumulator.push.apply(optionsAccumulator, _toConsumableArray(categorizedOption.options.map(function (option) {
return {
data: option.data,
id: "".concat(optionId, "-").concat(categorizedOption.index, "-").concat(option.index)
};
})));
} else {
optionsAccumulator.push({
data: categorizedOption.data,
id: "".concat(optionId, "-").concat(categorizedOption.index)
});
}
return optionsAccumulator;
}, []);
}
function buildFocusableOptions(props, selectValue) {
return buildFocusableOptionsFromCategorizedOptions(buildCategorizedOptions(props, selectValue));
}
function isFocusable(props, categorizedOption) {
var _props$inputValue = props.inputValue,
inputValue = _props$inputValue === void 0 ? '' : _props$inputValue;
var data = categorizedOption.data,
isSelected = categorizedOption.isSelected,
label = categorizedOption.label,
value = categorizedOption.value;
return (!shouldHideSelectedOptions(props) || !isSelected) && _filterOption(props, {
label: label,
value: value,
data: data
}, inputValue);
}
function getNextFocusedValue(state, nextSelectValue) {
var focusedValue = state.focusedValue,
lastSelectValue = state.selectValue;
var lastFocusedIndex = lastSelectValue.indexOf(focusedValue);
if (lastFocusedIndex > -1) {
var nextFocusedIndex = nextSelectValue.indexOf(focusedValue);
if (nextFocusedIndex > -1) {
// the focused value is still in the selectValue, return it
return focusedValue;
} else if (lastFocusedIndex < nextSelectValue.length) {
// the focusedValue is not present in the next selectValue array by
// reference, so return the new value at the same index
return nextSelectValue[lastFocusedIndex];
}
}
return null;
}
function getNextFocusedOption(state, options) {
var lastFocusedOption = state.focusedOption;
return lastFocusedOption && options.indexOf(lastFocusedOption) > -1 ? lastFocusedOption : options[0];
}
var getFocusedOptionId = function getFocusedOptionId(focusableOptionsWithIds, focusedOption) {
var _focusableOptionsWith;
var focusedOptionId = (_focusableOptionsWith = focusableOptionsWithIds.find(function (option) {
return option.data === focusedOption;
})) === null || _focusableOptionsWith === void 0 ? void 0 : _focusableOptionsWith.id;
return focusedOptionId || null;
};
var getOptionLabel = function getOptionLabel(props, data) {
return props.getOptionLabel(data);
};
var getOptionValue = function getOptionValue(props, data) {
return props.getOptionValue(data);
};
function _isOptionDisabled(props, option, selectValue) {
return typeof props.isOptionDisabled === 'function' ? props.isOptionDisabled(option, selectValue) : false;
}
function _isOptionSelected(props, option, selectValue) {
if (selectValue.indexOf(option) > -1) return true;
if (typeof props.isOptionSelected === 'function') {
return props.isOptionSelected(option, selectValue);
}
var candidate = getOptionValue(props, option);
return selectValue.some(function (i) {
return getOptionValue(props, i) === candidate;
});
}
function _filterOption(props, option, inputValue) {
return props.filterOption ? props.filterOption(option, inputValue) : true;
}
var shouldHideSelectedOptions = function shouldHideSelectedOptions(props) {
var hideSelectedOptions = props.hideSelectedOptions,
isMulti = props.isMulti;
if (hideSelectedOptions === undefined) return isMulti;
return hideSelectedOptions;
};
var instanceId = 1;
var Select = /*#__PURE__*/function (_Component) {
_inherits(Select, _Component);
var _super = _createSuper(Select);
// Misc. Instance Properties
// ------------------------------
// TODO
// Refs
// ------------------------------
// Lifecycle
// ------------------------------
function Select(_props) {
var _this;
_classCallCheck(this, Select);
_this = _super.call(this, _props);
_this.state = {
ariaSelection: null,
focusedOption: null,
focusedOptionId: null,
focusableOptionsWithIds: [],
focusedValue: null,
inputIsHidden: false,
isFocused: false,
selectValue: [],
clearFocusValueOnUpdate: false,
prevWasFocused: false,
inputIsHiddenAfterUpdate: undefined,
prevProps: undefined,
instancePrefix: ''
};
_this.blockOptionHover = false;
_this.isComposing = false;
_this.commonProps = void 0;
_this.initialTouchX = 0;
_this.initialTouchY = 0;
_this.openAfterFocus = false;
_this.scrollToFocusedOptionOnUpdate = false;
_this.userIsDragging = void 0;
_this.isAppleDevice = isAppleDevice();
_this.controlRef = null;
_this.getControlRef = function (ref) {
_this.controlRef = ref;
};
_this.focusedOptionRef = null;
_this.getFocusedOptionRef = function (ref) {
_this.focusedOptionRef = ref;
};
_this.menuListRef = null;
_this.getMenuListRef = function (ref) {
_this.menuListRef = ref;
};
_this.inputRef = null;
_this.getInputRef = function (ref) {
_this.inputRef = ref;
};
_this.focus = _this.focusInput;
_this.blur = _this.blurInput;
_this.onChange = function (newValue, actionMeta) {
var _this$props = _this.props,
onChange = _this$props.onChange,
name = _this$props.name;
actionMeta.name = name;
_this.ariaOnChange(newValue, actionMeta);
onChange(newValue, actionMeta);
};
_this.setValue = function (newValue, action, option) {
var _this$props2 = _this.props,
closeMenuOnSelect = _this$props2.closeMenuOnSelect,
isMulti = _this$props2.isMulti,
inputValue = _this$props2.inputValue;
_this.onInputChange('', {
action: 'set-value',
prevInputValue: inputValue
});
if (closeMenuOnSelect) {
_this.setState({
inputIsHiddenAfterUpdate: !isMulti
});
_this.onMenuClose();
}
// when the select value should change, we should reset focusedValue
_this.setState({
clearFocusValueOnUpdate: true
});
_this.onChange(newValue, {
action: action,
option: option
});
};
_this.selectOption = function (newValue) {
var _this$props3 = _this.props,
blurInputOnSelect = _this$props3.blurInputOnSelect,
isMulti = _this$props3.isMulti,
name = _this$props3.name;
var selectValue = _this.state.selectValue;
var deselected = isMulti && _this.isOptionSelected(newValue, selectValue);
var isDisabled = _this.isOptionDisabled(newValue, selectValue);
if (deselected) {
var candidate = _this.getOptionValue(newValue);
_this.setValue(index.multiValueAsValue(selectValue.filter(function (i) {
return _this.getOptionValue(i) !== candidate;
})), 'deselect-option', newValue);
} else if (!isDisabled) {
// Select option if option is not disabled
if (isMulti) {
_this.setValue(index.multiValueAsValue([].concat(_toConsumableArray(selectValue), [newValue])), 'select-option', newValue);
} else {
_this.setValue(index.singleValueAsValue(newValue), 'select-option');
}
} else {
_this.ariaOnChange(index.singleValueAsValue(newValue), {
action: 'select-option',
option: newValue,
name: name
});
return;
}
if (blurInputOnSelect) {
_this.blurInput();
}
};
_this.removeValue = function (removedValue) {
var isMulti = _this.props.isMulti;
var selectValue = _this.state.selectValue;
var candidate = _this.getOptionValue(removedValue);
var newValueArray = selectValue.filter(function (i) {
return _this.getOptionValue(i) !== candidate;
});
var newValue = index.valueTernary(isMulti, newValueArray, newValueArray[0] || null);
_this.onChange(newValue, {
action: 'remove-value',
removedValue: removedValue
});
_this.focusInput();
};
_this.clearValue = function () {
var selectValue = _this.state.selectValue;
_this.onChange(index.valueTernary(_this.props.isMulti, [], null), {
action: 'clear',
removedValues: selectValue
});
};
_this.popValue = function () {
var isMulti = _this.props.isMulti;
var selectValue = _this.state.selectValue;
var lastSelectedValue = selectValue[selectValue.length - 1];
var newValueArray = selectValue.slice(0, selectValue.length - 1);
var newValue = index.valueTernary(isMulti, newValueArray, newValueArray[0] || null);
_this.onChange(newValue, {
action: 'pop-value',
removedValue: lastSelectedValue
});
};
_this.getFocusedOptionId = function (focusedOption) {
return getFocusedOptionId(_this.state.focusableOptionsWithIds, focusedOption);
};
_this.getFocusableOptionsWithIds = function () {
return buildFocusableOptionsWithIds(buildCategorizedOptions(_this.props, _this.state.selectValue), _this.getElementId('option'));
};
_this.getValue = function () {
return _this.state.selectValue;
};
_this.cx = function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return index.classNames.apply(void 0, [_this.props.classNamePrefix].concat(args));
};
_this.getOptionLabel = function (data) {
return getOptionLabel(_this.props, data);
};
_this.getOptionValue = function (data) {
return getOptionValue(_this.props, data);
};
_this.getStyles = function (key, props) {
var unstyled = _this.props.unstyled;
var base = defaultStyles[key](props, unstyled);
base.boxSizing = 'border-box';
var custom = _this.props.styles[key];
return custom ? custom(base, props) : base;
};
_this.getClassNames = function (key, props) {
var _this$props$className, _this$props$className2;
return (_this$props$className = (_this$props$className2 = _this.props.classNames)[key]) === null || _this$props$className === void 0 ? void 0 : _this$props$className.call(_this$props$className2, props);
};
_this.getElementId = function (element) {
return "".concat(_this.state.instancePrefix, "-").concat(element);
};
_this.getComponents = function () {
return index.defaultComponents(_this.props);
};
_this.buildCategorizedOptions = function () {
return buildCategorizedOptions(_this.props, _this.state.selectValue);
};
_this.getCategorizedOptions = function () {
return _this.props.menuIsOpen ? _this.buildCategorizedOptions() : [];
};
_this.buildFocusableOptions = function () {
return buildFocusableOptionsFromCategorizedOptions(_this.buildCategorizedOptions());
};
_this.getFocusableOptions = function () {
return _this.props.menuIsOpen ? _this.buildFocusableOptions() : [];
};
_this.ariaOnChange = function (value, actionMeta) {
_this.setState({
ariaSelection: _objectSpread({
value: value
}, actionMeta)
});
};
_this.onMenuMouseDown = function (event) {
if (event.button !== 0) {
return;
}
event.stopPropagation();
event.preventDefault();
_this.focusInput();
};
_this.onMenuMouseMove = function (event) {
_this.blockOptionHover = false;
};
_this.onControlMouseDown = function (event) {
// Event captured by dropdown indicator
if (event.defaultPrevented) {
return;
}
var openMenuOnClick = _this.props.openMenuOnClick;
if (!_this.state.isFocused) {
if (openMenuOnClick) {
_this.openAfterFocus = true;
}
_this.focusInput();
} else if (!_this.props.menuIsOpen) {
if (openMenuOnClick) {
_this.openMenu('first');
}
} else {
if (event.target.tagName !== 'INPUT' && event.target.tagName !== 'TEXTAREA') {
_this.onMenuClose();
}
}
if (event.target.tagName !== 'INPUT' && event.target.tagName !== 'TEXTAREA') {
event.preventDefault();
}
};
_this.onDropdownIndicatorMouseDown = function (event) {
// ignore mouse events that weren't triggered by the primary button
if (event && event.type === 'mousedown' && event.button !== 0) {