/*! Copyright (c) 2017 Jed Watson. Licensed under the MIT License (MIT), see http://jedwatson.github.io/react-select */ import AutosizeInput from 'react-input-autosize'; import classNames from 'classnames'; import PropTypes from 'prop-types'; import React from 'react'; import { findDOMNode } from 'react-dom'; import defaultArrowRenderer from './utils/defaultArrowRenderer'; import defaultClearRenderer from './utils/defaultClearRenderer'; import defaultFilterOptions from './utils/defaultFilterOptions'; import defaultMenuRenderer from './utils/defaultMenuRenderer'; import Dropdown from './Dropdown'; import Option from './Option'; import OptionGroup from './OptionGroup'; import Value from './Value'; function clone(obj) { const copy = {}; for (let attr in obj) { if (obj.hasOwnProperty(attr)) { copy[attr] = obj[attr]; }; } return copy; } function isGroup (option) { return option && Array.isArray(option.options); } const stringifyValue = value => typeof value === 'string' ? value : (value !== null && JSON.stringify(value)) || ''; const stringOrNode = PropTypes.oneOfType([ PropTypes.string, PropTypes.node, ]); const stringOrNumber = PropTypes.oneOfType([ PropTypes.string, PropTypes.number ]); let instanceId = 1; const shouldShowValue = (state, props) => { const { inputValue, isPseudoFocused, isFocused } = state; const { onSelectResetsInput } = props; if (!inputValue) return true; if (!onSelectResetsInput){ return !(!isFocused && isPseudoFocused || isFocused && !isPseudoFocused); } return false; }; const shouldShowPlaceholder = (state, props, isOpen) => { const { inputValue, isPseudoFocused, isFocused } = state; const { onSelectResetsInput } = props; return !inputValue || !onSelectResetsInput && !isOpen && !isPseudoFocused && !isFocused; }; const handleRequired = (value, multi) => { if (!value) return true; return (multi ? value.length === 0 : Object.keys(value).length === 0); }; class Select extends React.Component { constructor (props) { super(props); [ 'clearValue', 'focusOption', 'getOptionLabel', 'handleInputBlur', 'handleInputChange', 'handleInputFocus', 'handleInputValueChange', 'handleKeyDown', 'handleMenuScroll', 'handleMouseDown', 'handleMouseDownOnArrow', 'handleMouseDownOnMenu', 'handleTouchEnd', 'handleTouchEndClearValue', 'handleTouchMove', 'handleTouchOutside', 'handleTouchStart', 'handleValueClick', 'onOptionRef', 'removeValue', 'selectValue', ].forEach((fn) => this[fn] = this[fn].bind(this)); this.state = { inputValue: '', isFocused: false, isOpen: false, isPseudoFocused: false, required: false, }; } componentWillMount () { this._flatOptions = this.flattenOptions(this.props.options); this._instancePrefix = 'react-select-' + (this.props.instanceId || ++instanceId) + '-'; const valueArray = this.getValueArray(this.props.value); if (this.props.required) { this.setState({ required: handleRequired(valueArray[0], this.props.multi), }); } } componentDidMount () { if (typeof this.props.autofocus !== 'undefined' && typeof console !== 'undefined') { console.warn('Warning: The autofocus prop has changed to autoFocus, support will be removed after react-select@1.0'); } if (this.props.autoFocus || this.props.autofocus) { this.focus(); } } componentWillReceiveProps (nextProps) { if (nextProps.options !== this.props.options) { this._flatOptions = this.flattenOptions(nextProps.options); } const valueArray = this.getValueArray(nextProps.value, nextProps); if (!nextProps.isOpen && this.props.isOpen) { this.closeMenu(); } else if (nextProps.isOpen && !this.props.isOpen) { this.setState({ isOpen: true }); } if (nextProps.required) { this.setState({ required: handleRequired(valueArray[0], nextProps.multi), }); } else if (this.props.required) { // Used to be required but it's not any more this.setState({ required: false }); } if (this.state.inputValue && this.props.value !== nextProps.value && nextProps.onSelectResetsInput) { this.setState({ inputValue: this.handleInputValueChange('') }); } } componentDidUpdate (prevProps, prevState) { // focus to the selected option if (this.menu && this.focused && this.state.isOpen && !this.hasScrolledToOption) { const focusedOptionNode = findDOMNode(this.focused); let menuNode = findDOMNode(this.menu); const scrollTop = menuNode.scrollTop; const scrollBottom = scrollTop + menuNode.offsetHeight; const optionTop = focusedOptionNode.offsetTop; const optionBottom = optionTop + focusedOptionNode.offsetHeight; if (scrollTop > optionTop || scrollBottom < optionBottom) { menuNode.scrollTop = focusedOptionNode.offsetTop; } // We still set hasScrolledToOption to true even if we didn't // actually need to scroll, as we've still confirmed that the // option is in view. this.hasScrolledToOption = true; } else if (!this.state.isOpen) { this.hasScrolledToOption = false; } if (this._scrollToFocusedOptionOnUpdate && this.focused && this.menu) { this._scrollToFocusedOptionOnUpdate = false; const focusedDOM = findDOMNode(this.focused); let menuDOM = findDOMNode(this.menu); const focusedRect = focusedDOM.getBoundingClientRect(); const menuRect = menuDOM.getBoundingClientRect(); if (focusedRect.bottom > menuRect.bottom) { menuDOM.scrollTop = (focusedDOM.offsetTop + focusedDOM.clientHeight - menuDOM.offsetHeight); } else if (focusedRect.top < menuRect.top) { menuDOM.scrollTop = focusedDOM.offsetTop; } } if (this.props.scrollMenuIntoView && this.menuContainer) { const menuContainerRect = this.menuContainer.getBoundingClientRect(); if (window.innerHeight < menuContainerRect.bottom + this.props.menuBuffer) { window.scrollBy(0, menuContainerRect.bottom + this.props.menuBuffer - window.innerHeight); } } if (prevProps.disabled !== this.props.disabled) { this.setState({ isFocused: false }); // eslint-disable-line react/no-did-update-set-state this.closeMenu(); } if (prevState.isOpen !== this.state.isOpen) { this.toggleTouchOutsideEvent(this.state.isOpen); const handler = this.state.isOpen ? this.props.onOpen : this.props.onClose; handler && handler(); } } componentWillUnmount () { this.toggleTouchOutsideEvent(false); } toggleTouchOutsideEvent (enabled) { if (enabled) { if (!document.addEventListener && document.attachEvent) { document.attachEvent('ontouchstart', this.handleTouchOutside); } else { document.addEventListener('touchstart', this.handleTouchOutside); } } else { if (!document.removeEventListener && document.detachEvent) { document.detachEvent('ontouchstart', this.handleTouchOutside); } else { document.removeEventListener('touchstart', this.handleTouchOutside); } } } handleTouchOutside (event) { // handle touch outside on ios to dismiss menu if (this.wrapper && !this.wrapper.contains(event.target)) { this.closeMenu(); } } focus () { if (!this.input) return; this.input.focus(); } blurInput () { if (!this.input) return; this.input.blur(); } handleTouchMove () { // Set a flag that the view is being dragged this.dragging = true; } handleTouchStart () { // Set a flag that the view is not being dragged this.dragging = false; } handleTouchEnd (event) { // Check if the view is being dragged, In this case // we don't want to fire the click event (because the user only wants to scroll) if (this.dragging) return; // Fire the mouse events this.handleMouseDown(event); } handleTouchEndClearValue (event) { // Check if the view is being dragged, In this case // we don't want to fire the click event (because the user only wants to scroll) if (this.dragging) return; // Clear the value this.clearValue(event); } handleMouseDown (event) { // if the event was triggered by a mousedown and not the primary // button, or if the component is disabled, ignore it. if (this.props.disabled || (event.type === 'mousedown' && event.button !== 0)) { return; } if (event.target.tagName === 'INPUT') { if (!this.state.isFocused) { this._openAfterFocus = this.props.openOnClick; this.focus(); } else if (!this.state.isOpen) { this.setState({ isOpen: true, isPseudoFocused: false, }); } return; } // prevent default event handlers event.preventDefault(); // for the non-searchable select, toggle the menu if (!this.props.searchable) { // This code means that if a select is searchable, onClick the options menu will not appear, only on subsequent click will it open. this.focus(); return this.setState({ isOpen: !this.state.isOpen, }); } if (this.state.isFocused) { // On iOS, we can get into a state where we think the input is focused but it isn't really, // since iOS ignores programmatic calls to input.focus() that weren't triggered by a click event. // Call focus() again here to be safe. this.focus(); let input = this.input; let toOpen = true; if (typeof input.getInput === 'function') { // Get the actual DOM input if the ref is an component input = input.getInput(); } // clears the value so that the cursor will be at the end of input when the component re-renders input.value = ''; if (this._focusAfterClear) { toOpen = false; this._focusAfterClear = false; } // if the input is focused, ensure the menu is open this.setState({ isOpen: toOpen, isPseudoFocused: false, focusedOption: null, }); } else { // otherwise, focus the input and open the menu this._openAfterFocus = this.props.openOnClick; this.focus(); this.setState({ focusedOption: null }); } } handleMouseDownOnArrow (event) { // if the event was triggered by a mousedown and not the primary // button, or if the component is disabled, ignore it. if (this.props.disabled || (event.type === 'mousedown' && event.button !== 0)) { return; } if (this.state.isOpen) { // prevent default event handlers event.stopPropagation(); event.preventDefault(); // close the menu this.closeMenu(); } else { // If the menu isn't open, let the event bubble to the main handleMouseDown this.setState({ isOpen: true, }); } } handleMouseDownOnMenu (event) { // if the event was triggered by a mousedown and not the primary // button, or if the component is disabled, ignore it. if (this.props.disabled || (event.type === 'mousedown' && event.button !== 0)) { return; } event.stopPropagation(); event.preventDefault(); this._openAfterFocus = true; this.focus(); } closeMenu () { if(this.props.onCloseResetsInput) { this.setState({ inputValue: this.handleInputValueChange(''), isOpen: false, isPseudoFocused: this.state.isFocused && !this.props.multi, }); } else { this.setState({ isOpen: false, isPseudoFocused: this.state.isFocused && !this.props.multi }); } this.hasScrolledToOption = false; } handleInputFocus (event) { if (this.props.disabled) return; let toOpen = this.state.isOpen || this._openAfterFocus || this.props.openOnFocus; toOpen = this._focusAfterClear ? false : toOpen; //if focus happens after clear values, don't open dropdown yet. if (this.props.onFocus) { this.props.onFocus(event); } this.setState({ isFocused: true, isOpen: !!toOpen, }); this._focusAfterClear = false; this._openAfterFocus = false; } handleInputBlur (event) { // The check for menu.contains(activeElement) is necessary to prevent IE11's scrollbar from closing the menu in certain contexts. if (this.menu && (this.menu === document.activeElement || this.menu.contains(document.activeElement))) { this.focus(); return; } if (this.props.onBlur) { this.props.onBlur(event); } let onBlurredState = { isFocused: false, isOpen: false, isPseudoFocused: false, }; if (this.props.onBlurResetsInput) { onBlurredState.inputValue = this.handleInputValueChange(''); } this.setState(onBlurredState); } handleInputChange (event) { let newInputValue = event.target.value; if (this.state.inputValue !== event.target.value) { newInputValue = this.handleInputValueChange(newInputValue); } this.setState({ inputValue: newInputValue, isOpen: true, isPseudoFocused: false, }); } setInputValue(newValue) { if (this.props.onInputChange) { let nextState = this.props.onInputChange(newValue); if (nextState != null && typeof nextState !== 'object') { newValue = '' + nextState; } } this.setState({ inputValue: newValue }); } handleInputValueChange(newValue) { if (this.props.onInputChange) { let nextState = this.props.onInputChange(newValue); // Note: != used deliberately here to catch undefined and null if (nextState != null && typeof nextState !== 'object') { newValue = '' + nextState; } } return newValue; } handleKeyDown (event) { if (this.props.disabled) return; if (typeof this.props.onInputKeyDown === 'function') { this.props.onInputKeyDown(event); if (event.defaultPrevented) { return; } } switch (event.keyCode) { case 8: // backspace if (!this.state.inputValue && this.props.backspaceRemoves) { event.preventDefault(); this.popValue(); } break; case 9: // tab if (event.shiftKey || !this.state.isOpen || !this.props.tabSelectsValue) { break; } event.preventDefault(); this.selectFocusedOption(); break; case 13: // enter event.preventDefault(); event.stopPropagation(); if (this.state.isOpen) { this.selectFocusedOption(); } else { this.focusNextOption(); } break; case 27: // escape event.preventDefault(); if (this.state.isOpen) { this.closeMenu(); event.stopPropagation(); } else if (this.props.clearable && this.props.escapeClearsValue) { this.clearValue(event); event.stopPropagation(); } break; case 32: // space if (this.props.searchable) { break; } event.preventDefault(); if (!this.state.isOpen) { this.focusNextOption(); break; } event.stopPropagation(); this.selectFocusedOption(); break; case 38: // up event.preventDefault(); this.focusPreviousOption(); break; case 40: // down event.preventDefault(); this.focusNextOption(); break; case 33: // page up event.preventDefault(); this.focusPageUpOption(); break; case 34: // page down event.preventDefault(); this.focusPageDownOption(); break; case 35: // end key if (event.shiftKey) { break; } event.preventDefault(); this.focusEndOption(); break; case 36: // home key if (event.shiftKey) { break; } event.preventDefault(); this.focusStartOption(); break; case 46: // delete event.preventDefault(); if (!this.state.inputValue && this.props.deleteRemoves) { this.popValue(); } break; } } handleValueClick (option, event) { if (!this.props.onValueClick) return; this.props.onValueClick(option, event); } handleMenuScroll (event) { if (!this.props.onMenuScrollToBottom) return; let { target } = event; if (target.scrollHeight > target.offsetHeight && (target.scrollHeight - target.offsetHeight - target.scrollTop) <= 0) { this.props.onMenuScrollToBottom(); } } getOptionLabel (op) { return op[this.props.labelKey]; } /** * Turns a value into an array from the given options * @param {String|Number|Array} value - the value of the select input * @param {Object} nextProps - optionally specify the nextProps so the returned array uses the latest configuration * @returns {Array} the value of the select represented in an array */ getValueArray (value, nextProps = undefined) { /** support optionally passing in the `nextProps` so `componentWillReceiveProps` updates will function as expected */ const props = typeof nextProps === 'object' ? nextProps : this.props; if (props.multi) { if (typeof value === 'string') { value = value.split(props.delimiter); } if (!Array.isArray(value)) { if (value === null || value === undefined) return []; value = [value]; } return value.map(value => this.expandValue(value, props)).filter(i => i); } const expandedValue = this.expandValue(value, props); return expandedValue ? [expandedValue] : []; } /** * Retrieve a value from the given options and valueKey * @param {String|Number|Array} value - the selected value(s) * @param {Object} props - the Select component's props (or nextProps) */ expandValue (value, props) { const valueType = typeof value; if (valueType !== 'string' && valueType !== 'number' && valueType !== 'boolean') return value; let { labelKey, renderInvalidValues, valueKey } = props; let options = this._flatOptions; if (!options) return; for (let i = 0; i < options.length; i++) { if (String(options[i][valueKey]) === String(value)) return options[i]; } // no matching option, return an invalid option if renderInvalidValues is enabled if (renderInvalidValues) { this._invalidOptions = this._invalidOptions || {}; this._invalidOptions[value] = this._invalidOptions[value] || { invalid: true, [labelKey]: value, [valueKey]: value }; return this._invalidOptions[value]; } } setValue (value) { if (this.props.autoBlur) { this.blurInput(); } if (this.props.required) { const required = handleRequired(value, this.props.multi); this.setState({ required }); } if (this.props.simpleValue && value) { value = this.props.multi ? value.map(i => i[this.props.valueKey]).join(this.props.delimiter) : value[this.props.valueKey]; } if (this.props.onChange) { this.props.onChange(value); } } selectValue (value) { // NOTE: we actually add/set the value in a callback to make sure the // input value is empty to avoid styling issues in Chrome if (this.props.closeOnSelect) { this.hasScrolledToOption = false; } const updatedValue = this.props.onSelectResetsInput ? '' : this.state.inputValue; if (this.props.multi) { this.setState({ focusedIndex: null, inputValue: this.handleInputValueChange(updatedValue), isOpen: !this.props.closeOnSelect, }, () => { const valueArray = this.getValueArray(this.props.value); if (valueArray.some(i => i[this.props.valueKey] === value[this.props.valueKey])) { this.removeValue(value); } else { this.addValue(value); } }); } else { this.setState({ inputValue: this.handleInputValueChange(updatedValue), isOpen: !this.props.closeOnSelect, isPseudoFocused: this.state.isFocused, }, () => { this.setValue(value); }); } } addValue (value) { let valueArray = this.getValueArray(this.props.value); const visibleOptions = this._visibleOptions.filter(val => !val.disabled); const lastValueIndex = visibleOptions.indexOf(value); this.setValue(valueArray.concat(value)); if (visibleOptions.length - 1 === lastValueIndex) { // the last option was selected; focus the second-last one this.focusOption(visibleOptions[lastValueIndex - 1]); } else if (visibleOptions.length > lastValueIndex) { // focus the option below the selected one this.focusOption(visibleOptions[lastValueIndex + 1]); } } popValue () { let valueArray = this.getValueArray(this.props.value); if (!valueArray.length) return; if (valueArray[valueArray.length-1].clearableValue === false) return; this.setValue(this.props.multi ? valueArray.slice(0, valueArray.length - 1) : null); } removeValue (value) { let valueArray = this.getValueArray(this.props.value); this.setValue(valueArray.filter(i => i[this.props.valueKey] !== value[this.props.valueKey])); this.focus(); } clearValue (event) { // if the event was triggered by a mousedown and not the primary // button, ignore it. if (event && event.type === 'mousedown' && event.button !== 0) { return; } event.preventDefault(); this.setValue(this.getResetValue()); this.setState({ inputValue: this.handleInputValueChange(''), isOpen: false, }, this.focus); this._focusAfterClear = true; } getResetValue () { if (this.props.resetValue !== undefined) { return this.props.resetValue; } else if (this.props.multi) { return []; } else { return null; } } focusOption (option) { this.setState({ focusedOption: option }); } focusNextOption () { this.focusAdjacentOption('next'); } focusPreviousOption () { this.focusAdjacentOption('previous'); } focusPageUpOption () { this.focusAdjacentOption('page_up'); } focusPageDownOption () { this.focusAdjacentOption('page_down'); } focusStartOption () { this.focusAdjacentOption('start'); } focusEndOption () { this.focusAdjacentOption('end'); } focusAdjacentOption (dir) { const options = this._visibleOptions .map((option, index) => ({ option, index })) .filter(option => !option.option.disabled); this._scrollToFocusedOptionOnUpdate = true; if (!this.state.isOpen) { const newState = { focusedOption: this._focusedOption || (options.length ? options[dir === 'next' ? 0 : options.length - 1].option : null), isOpen: true, }; if (this.props.onSelectResetsInput) { newState.inputValue = ''; } this.setState(newState); return; } if (!options.length) return; let focusedIndex = -1; for (let i = 0; i < options.length; i++) { if (this._focusedOption === options[i].option) { focusedIndex = i; break; } } if (dir === 'next' && focusedIndex !== -1 ) { focusedIndex = (focusedIndex + 1) % options.length; } else if (dir === 'previous') { if (focusedIndex > 0) { focusedIndex = focusedIndex - 1; } else { focusedIndex = options.length - 1; } } else if (dir === 'start') { focusedIndex = 0; } else if (dir === 'end') { focusedIndex = options.length - 1; } else if (dir === 'page_up') { const potentialIndex = focusedIndex - this.props.pageSize; if (potentialIndex < 0) { focusedIndex = 0; } else { focusedIndex = potentialIndex; } } else if (dir === 'page_down') { const potentialIndex = focusedIndex + this.props.pageSize; if (potentialIndex > options.length - 1) { focusedIndex = options.length - 1; } else { focusedIndex = potentialIndex; } } if (focusedIndex === -1) { focusedIndex = 0; } this.setState({ focusedIndex: options[focusedIndex].index, focusedOption: options[focusedIndex].option }); } getFocusedOption () { return this._focusedOption; } selectFocusedOption () { if (this._focusedOption) { return this.selectValue(this._focusedOption); } } renderLoading () { if (!this.props.isLoading) return; return (