@kepler.gl/components 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/common/item-selector/typeahead.js

@@ -0,0 +1,428 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component, createRef } from 'react';
+import fuzzy from 'fuzzy';
+import classNames from 'classnames';
+import styled from 'styled-components';
+import { console as Console } from 'global/window';
+import Accessor from './accessor';
+import DropdownList, { ListItem } from './dropdown-list';
+import { Search } from '../icons';
+import { KeyEvent } from '@kepler.gl/constants';
+import { shouldForwardProp } from '../styled-components';
+var DEFAULT_CLASS = 'typeahead';
+/**
+ * Copied mostly from 'react-typeahead', an auto-completing text input
+ *
+ * Renders an text input that shows options nearby that you can use the
+ * keyboard or mouse to select.
+ */
+
+var TypeaheadWrapper = styled.div.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  background-color: ", ";\n  box-shadow: ", ";\n\n  &:focus {\n    outline: 0;\n  }\n"])), function (props) {
+  return props.light ? props.theme.dropdownListBgdLT : props.theme.dropdownListBgd;
+}, function (props) {
+  return props.theme.dropdownListShadow;
+});
+var InputBox = styled.div.attrs({
+  className: 'typeahead__input_box'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  padding: 8px;\n"])));
+var TypeaheadInput = styled.input.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  ", "\n  &:hover {\n    cursor: pointer;\n    background-color: ", ";\n  }\n"])), function (props) {
+  return props.light ? props.theme.inputLT : props.theme.secondaryInput;
+}, function (props) {
+  return props.light ? props.theme.selectBackgroundLT : props.theme.secondaryInputBgd;
+});
+var InputIcon = styled.div.attrs({
+  className: 'typeahead__input_icon'
+})(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  position: absolute;\n  right: 15px;\n  top: 14px;\n  color: ", ";\n"])), function (props) {
+  return props.theme.inputPlaceholderColor;
+});
+function generateSearchFunction(props) {
+  var searchOptions = props.searchOptions,
+    filterOption = props.filterOption;
+  if (typeof searchOptions === 'function') {
+    if (filterOption !== null) {
+      Console.warn('searchOptions prop is being used, filterOption prop will be ignored');
+    }
+    return searchOptions;
+  } else if (typeof filterOption === 'function') {
+    // use custom filter option
+    return function (value, options) {
+      return options.filter(function (o) {
+        return filterOption(value, o);
+      });
+    };
+  }
+  var mapper = typeof filterOption === 'string' ? Accessor.generateAccessor(filterOption) : Accessor.IDENTITY_FN;
+  return function (value, options) {
+    return fuzzy.filter(value, options, {
+      extract: mapper
+    }).map(function (res) {
+      return options[res.index];
+    });
+  };
+}
+function searchOptionsOnInput(inputValue, props) {
+  var searchOptions = generateSearchFunction(props);
+  return searchOptions(inputValue, props.options);
+}
+function getOptionsForValue(value, props, state) {
+  var options = props.options,
+    showOptionsWhenEmpty = props.showOptionsWhenEmpty;
+  if (!props.searchable) {
+    // directly pass through options if can not be searched
+    return options;
+  }
+  if (shouldSkipSearch(value, state, showOptionsWhenEmpty)) {
+    return options;
+  }
+  var searchOptions = generateSearchFunction(props);
+  return searchOptions(value, options);
+}
+function shouldSkipSearch(input, state, showOptionsWhenEmpty) {
+  var emptyValue = !input || input.trim().length === 0;
+
+  // this.state must be checked because it may not be defined yet if this function
+  // is called from within getInitialState
+  var isFocused = state && state.isFocused;
+  return !(showOptionsWhenEmpty && isFocused) && emptyValue;
+}
+function noop() {
+  return;
+}
+var Typeahead = /*#__PURE__*/function (_Component) {
+  function Typeahead(props) {
+    var _this;
+    _classCallCheck(this, Typeahead);
+    _this = _callSuper(this, Typeahead, [props]);
+    _defineProperty(_this, "root", /*#__PURE__*/createRef());
+    _defineProperty(_this, "entry", /*#__PURE__*/createRef());
+    _defineProperty(_this, "focus", function () {
+      if (_this.entry.current) {
+        _this.entry.current.focus();
+      }
+    });
+    _defineProperty(_this, "_hasCustomValue", function () {
+      var _this$state$entryValu;
+      return Number(_this.props.allowCustomValues) > 0 && Number((_this$state$entryValu = _this.state.entryValue) === null || _this$state$entryValu === void 0 ? void 0 : _this$state$entryValu.length) >= Number(_this.props.allowCustomValues) && _this.state.searchResults.indexOf(_this.state.entryValue) < 0;
+    });
+    _defineProperty(_this, "_getCustomValue", function () {
+      return _this._hasCustomValue() ? _this.state.entryValue : null;
+    });
+    _defineProperty(_this, "_onOptionSelected", function (option, event) {
+      var _this$props$onOptionS, _this$props;
+      if (_this.props.searchable) {
+        // reset entry input
+        _this.setState({
+          // reset search options when selection has been made
+          searchResults: _this.props.options || [],
+          selection: '',
+          entryValue: ''
+        });
+      }
+      (_this$props$onOptionS = (_this$props = _this.props).onOptionSelected) === null || _this$props$onOptionS === void 0 || _this$props$onOptionS.call(_this$props, option, event);
+    });
+    // use () => {} to avoid binding 'this'
+    _defineProperty(_this, "_onTextEntryUpdated", function () {
+      if (_this.props.searchable) {
+        var _this$entry$current;
+        var value = (_this$entry$current = _this.entry.current) === null || _this$entry$current === void 0 ? void 0 : _this$entry$current.value;
+        _this.setState({
+          searchResults: searchOptionsOnInput(value, _this.props),
+          selection: '',
+          entryValue: value
+        });
+      }
+    });
+    _defineProperty(_this, "_onEnter", function (event) {
+      var selection = _this.getSelection();
+      if (!selection) {
+        var _this$props$onKeyDown, _this$props2;
+        (_this$props$onKeyDown = (_this$props2 = _this.props).onKeyDown) === null || _this$props$onKeyDown === void 0 || _this$props$onKeyDown.call(_this$props2, event);
+      }
+      _this._onOptionSelected(selection, event);
+    });
+    _defineProperty(_this, "_onEscape", function () {
+      _this.setState({
+        selectionIndex: null
+      });
+    });
+    _defineProperty(_this, "_onTab", function (event) {
+      var selection = _this.getSelection();
+      var option = selection ? selection : _this.state.searchResults.length > 0 ? _this.state.searchResults[0] : null;
+      if (option === null && _this._hasCustomValue()) {
+        option = _this._getCustomValue();
+      }
+      if (option !== null) {
+        return _this._onOptionSelected(option, event);
+      }
+    });
+    _defineProperty(_this, "eventMap", function () {
+      var events = {};
+      events[KeyEvent.DOM_VK_UP] = _this.navUp;
+      events[KeyEvent.DOM_VK_DOWN] = _this.navDown;
+      events[KeyEvent.DOM_VK_RETURN] = events[KeyEvent.DOM_VK_ENTER] = _this._onEnter;
+      events[KeyEvent.DOM_VK_ESCAPE] = _this._onEscape;
+      events[KeyEvent.DOM_VK_TAB] = _this._onTab;
+      return events;
+    });
+    _defineProperty(_this, "_nav", function (delta) {
+      if (!_this._hasHint()) {
+        return;
+      }
+      var newIndex = _this.state.selectionIndex === null ? delta === 1 ? 0 : delta : _this.state.selectionIndex + delta;
+      var length = _this.props.maxVisible ? _this.state.searchResults.slice(0, _this.props.maxVisible).length : _this.state.searchResults.length;
+      if (_this._hasCustomValue()) {
+        length += 1;
+      }
+      if (newIndex < 0) {
+        newIndex += length;
+      } else if (newIndex >= length) {
+        newIndex -= length;
+      }
+      _this.setState({
+        selectionIndex: newIndex
+      });
+    });
+    _defineProperty(_this, "navDown", function () {
+      _this._nav(1);
+    });
+    _defineProperty(_this, "navUp", function () {
+      _this._nav(-1);
+    });
+    _defineProperty(_this, "_onChange", function (event) {
+      if (_this.props.onChange) {
+        _this.props.onChange(event);
+      }
+      _this._onTextEntryUpdated();
+    });
+    _defineProperty(_this, "_onKeyDown", function (event) {
+      // If there are no visible elements, don't perform selector navigation.
+      // Just pass this up to the upstream onKeydown handler.
+      // Also skip if the user is pressing the shift key, since none of our handlers are looking for shift
+      if (!_this._hasHint() || event.shiftKey) {
+        var _this$props$onKeyDown2, _this$props3;
+        return (_this$props$onKeyDown2 = (_this$props3 = _this.props).onKeyDown) === null || _this$props$onKeyDown2 === void 0 ? void 0 : _this$props$onKeyDown2.call(_this$props3, event);
+      }
+      var handler = _this.eventMap()[event.keyCode];
+      if (handler) {
+        handler(event);
+      } else {
+        var _this$props$onKeyDown3, _this$props4;
+        return (_this$props$onKeyDown3 = (_this$props4 = _this.props).onKeyDown) === null || _this$props$onKeyDown3 === void 0 ? void 0 : _this$props$onKeyDown3.call(_this$props4, event);
+      }
+      // Don't propagate the keystroke back to the DOM/browser
+      event.preventDefault();
+    });
+    _defineProperty(_this, "_onFocus", function (event) {
+      _this.setState({
+        isFocused: true
+      });
+      if (_this.props.onFocus) {
+        return _this.props.onFocus(event);
+      }
+    });
+    _defineProperty(_this, "_onBlur", function (event) {
+      _this.setState({
+        isFocused: false
+      });
+      if (_this.props.onBlur) {
+        return _this.props.onBlur(event);
+      }
+    });
+    _this.state = {
+      // initiate searchResults with options
+      searchResults: _this.props.options || [],
+      // This should be called something else, 'entryValue'
+      entryValue: _this.props.value || _this.props.initialValue,
+      // A valid typeahead value
+      selection: _this.props.value,
+      // Index of the selection
+      selectionIndex: null,
+      // Keep track of the focus state of the input element, to determine
+      // whether to show options when empty (if showOptionsWhenEmpty is true)
+      isFocused: false
+    };
+    return _this;
+  }
+  _inherits(Typeahead, _Component);
+  return _createClass(Typeahead, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      // call focus on entry or div to trigger key events listener
+      if (this.props.autoFocus) {
+        if (this.entry.current) {
+          this.entry.current.focus();
+        } else {
+          var _this$root$current;
+          (_this$root$current = this.root.current) === null || _this$root$current === void 0 || _this$root$current.focus();
+        }
+      }
+    }
+  }, {
+    key: "_renderIncrementalSearchResults",
+    value: function _renderIncrementalSearchResults() {
+      var _this$props$customLis = this.props.customListComponent,
+        CustomListComponent = _this$props$customLis === void 0 ? DropdownList : _this$props$customLis;
+      return /*#__PURE__*/React.createElement(CustomListComponent, {
+        fixedOptions: this.props.fixedOptions,
+        options: this.state.searchResults,
+        areResultsTruncated: false,
+        resultsTruncatedMessage: this.props.resultsTruncatedMessage,
+        onOptionSelected: this._onOptionSelected,
+        allowCustomValues: this.props.allowCustomValues,
+        customValue: this._getCustomValue(),
+        customClasses: this.props.customClasses,
+        customListItemComponent: this.props.customListItemComponent,
+        customListHeaderComponent: this.props.customListHeaderComponent,
+        selectionIndex: this.state.selectionIndex,
+        defaultClassNames: this.props.defaultClassNames,
+        displayOption: this.props.displayOption,
+        selectedItems: this.props.selectedItems,
+        light: this.props.light
+      });
+    }
+  }, {
+    key: "getSelection",
+    value: function getSelection() {
+      var index = this.state.selectionIndex;
+      if (index === null) {
+        return null;
+      }
+      index = Number(index);
+      if (this._hasCustomValue()) {
+        if (index === 0) {
+          return this.state.entryValue;
+        }
+        index--;
+      }
+      if (this._hasFixedOptions()) {
+        var _this$props$fixedOpti, _this$props$fixedOpti2, _this$props$fixedOpti3;
+        return index < Number((_this$props$fixedOpti = this.props.fixedOptions) === null || _this$props$fixedOpti === void 0 ? void 0 : _this$props$fixedOpti.length) ? (_this$props$fixedOpti2 = this.props.fixedOptions) === null || _this$props$fixedOpti2 === void 0 ? void 0 : _this$props$fixedOpti2[index] : this.state.searchResults[index - Number((_this$props$fixedOpti3 = this.props.fixedOptions) === null || _this$props$fixedOpti3 === void 0 ? void 0 : _this$props$fixedOpti3.length)];
+      }
+      return this.state.searchResults[index];
+    }
+  }, {
+    key: "_renderHiddenInput",
+    value: function _renderHiddenInput() {
+      if (!this.props.name) {
+        return null;
+      }
+      return /*#__PURE__*/React.createElement("input", {
+        type: "hidden",
+        name: this.props.name,
+        value: this.state.selection
+      });
+    }
+  }, {
+    key: "_hasHint",
+    value: function _hasHint() {
+      return this.state.searchResults.length > 0 || this._hasCustomValue();
+    }
+  }, {
+    key: "_hasFixedOptions",
+    value: function _hasFixedOptions() {
+      return Array.isArray(this.props.fixedOptions) && this.props.fixedOptions.length;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props$customCla, _this$props$customCla2;
+      var inputClasses = {};
+      inputClasses[(_this$props$customCla = this.props.customClasses) === null || _this$props$customCla === void 0 ? void 0 : _this$props$customCla.input] = Boolean((_this$props$customCla2 = this.props.customClasses) === null || _this$props$customCla2 === void 0 ? void 0 : _this$props$customCla2.input);
+      var inputClassList = classNames(inputClasses);
+      var classes = _defineProperty({}, DEFAULT_CLASS, this.props.defaultClassNames);
+      classes[this.props.className ? this.props.className : ''] = Boolean(this.props.className);
+      var classList = classNames(classes);
+      return /*#__PURE__*/React.createElement(TypeaheadWrapper, {
+        className: classList,
+        ref: this.root,
+        tabIndex: 0,
+        onKeyDown: this._onKeyDown,
+        onKeyPress: this.props.onKeyPress,
+        onKeyUp: this.props.onKeyUp,
+        onFocus: this._onFocus,
+        light: this.props.light
+      }, this._renderHiddenInput(), this.props.searchable ? /*#__PURE__*/React.createElement(InputBox, null, /*#__PURE__*/React.createElement(TypeaheadInput, _extends({
+        ref: this.entry,
+        type: "text",
+        disabled: this.props.disabled
+      }, this.props.inputProps, {
+        placeholder: this.props.placeholder,
+        className: inputClassList,
+        value: this.state.entryValue,
+        onChange: this._onChange,
+        onBlur: this._onBlur,
+        light: this.props.light
+      })), /*#__PURE__*/React.createElement(InputIcon, null, /*#__PURE__*/React.createElement(this.props.inputIcon, {
+        height: "18px"
+      }))) : null, this._renderIncrementalSearchResults());
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      if (props.options === state.prevOptions) {
+        return {};
+      }
+
+      //  invoked after a component is instantiated as well as before it is re-rendered
+      var searchResults = getOptionsForValue(state.entryValue, props, state);
+      return {
+        searchResults: searchResults,
+        prevOptions: props.options
+      };
+    }
+  }]);
+}(Component);
+_defineProperty(Typeahead, "defaultProps", {
+  options: [],
+  customClasses: {
+    results: 'list-selector',
+    input: 'typeahead__input',
+    listItem: 'list__item',
+    listAnchor: 'list__item__anchor'
+  },
+  allowCustomValues: 0,
+  initialValue: '',
+  value: '',
+  placeholder: '',
+  disabled: false,
+  textarea: false,
+  inputProps: {},
+  onOptionSelected: noop,
+  onChange: noop,
+  onKeyDown: noop,
+  onKeyPress: noop,
+  onKeyUp: noop,
+  onFocus: noop,
+  onBlur: noop,
+  filterOption: null,
+  searchOptions: null,
+  inputDisplayOption: null,
+  defaultClassNames: true,
+  customListComponent: DropdownList,
+  customListItemComponent: ListItem,
+  inputIcon: Search,
+  customListHeaderComponent: null,
+  showOptionsWhenEmpty: true,
+  searchable: true,
+  resultsTruncatedMessage: null,
+  autoFocus: true
+});
+export default Typeahead;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createRef","fuzzy","classNames","styled","console","Console","Accessor","DropdownList","ListItem","Search","KeyEvent","shouldForwardProp","DEFAULT_CLASS","TypeaheadWrapper","div","withConfig","_templateObject","_taggedTemplateLiteral","props","light","theme","dropdownListBgdLT","dropdownListBgd","dropdownListShadow","InputBox","attrs","className","_templateObject2","TypeaheadInput","input","_templateObject3","inputLT","secondaryInput","selectBackgroundLT","secondaryInputBgd","InputIcon","_templateObject4","inputPlaceholderColor","generateSearchFunction","searchOptions","filterOption","warn","value","options","filter","o","mapper","generateAccessor","IDENTITY_FN","extract","map","res","index","searchOptionsOnInput","inputValue","getOptionsForValue","state","showOptionsWhenEmpty","searchable","shouldSkipSearch","emptyValue","trim","length","isFocused","noop","Typeahead","_Component","_this","_classCallCheck","_callSuper","_defineProperty","entry","current","focus","_this$state$entryValu","Number","allowCustomValues","entryValue","searchResults","indexOf","_hasCustomValue","option","event","_this$props$onOptionS","_this$props","setState","selection","onOptionSelected","call","_this$entry$current","getSelection","_this$props$onKeyDown","_this$props2","onKeyDown","_onOptionSelected","selectionIndex","_getCustomValue","events","DOM_VK_UP","navUp","DOM_VK_DOWN","navDown","DOM_VK_RETURN","DOM_VK_ENTER","_onEnter","DOM_VK_ESCAPE","_onEscape","DOM_VK_TAB","_onTab","delta","_hasHint","newIndex","maxVisible","slice","_nav","onChange","_onTextEntryUpdated","shiftKey","_this$props$onKeyDown2","_this$props3","handler","eventMap","keyCode","_this$props$onKeyDown3","_this$props4","preventDefault","onFocus","onBlur","initialValue","_inherits","_createClass","key","componentDidMount","autoFocus","_this$root$current","root","_renderIncrementalSearchResults","_this$props$customLis","customListComponent","CustomListComponent","createElement","fixedOptions","areResultsTruncated","resultsTruncatedMessage","customValue","customClasses","customListItemComponent","customListHeaderComponent","defaultClassNames","displayOption","selectedItems","_hasFixedOptions","_this$props$fixedOpti","_this$props$fixedOpti2","_this$props$fixedOpti3","_renderHiddenInput","name","type","Array","isArray","render","_this$props$customCla","_this$props$customCla2","inputClasses","Boolean","inputClassList","classes","classList","ref","tabIndex","_onKeyDown","onKeyPress","onKeyUp","_onFocus","_extends","disabled","inputProps","placeholder","_onChange","_onBlur","inputIcon","height","getDerivedStateFromProps","prevOptions","results","listItem","listAnchor","textarea","inputDisplayOption"],"sources":["../../../../src/common/item-selector/typeahead.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, createRef, ElementType, KeyboardEventHandler} from 'react';\nimport fuzzy from 'fuzzy';\nimport classNames from 'classnames';\nimport styled, {IStyledComponent} from 'styled-components';\nimport {console as Console} from 'global/window';\n\nimport Accessor from './accessor';\nimport DropdownList, {ListItem} from './dropdown-list';\nimport {Search} from '../icons';\nimport {KeyEvent} from '@kepler.gl/constants';\nimport {BaseComponentProps} from '../../types';\nimport {shouldForwardProp} from '../styled-components';\nconst DEFAULT_CLASS = 'typeahead';\n/**\n * Copied mostly from 'react-typeahead', an auto-completing text input\n *\n * Renders an text input that shows options nearby that you can use the\n * keyboard or mouse to select.\n */\n\nexport type TypeaheadWrapperProps = BaseComponentProps & {\n  light?: boolean;\n  ref: React.RefObject<HTMLDivElement | null>;\n};\n\nconst TypeaheadWrapper: IStyledComponent<'web', TypeaheadWrapperProps> = styled.div.withConfig({\n  shouldForwardProp\n})<TypeaheadWrapperProps>`\n  display: flex;\n  flex-direction: column;\n  background-color: ${props =>\n    props.light ? props.theme.dropdownListBgdLT : props.theme.dropdownListBgd};\n  box-shadow: ${props => props.theme.dropdownListShadow};\n\n  &:focus {\n    outline: 0;\n  }\n`;\n\nconst InputBox = styled.div.attrs({\n  className: 'typeahead__input_box'\n})`\n  padding: 8px;\n`;\n\nexport type TypeaheadInputProps = BaseComponentProps & {\n  light?: boolean;\n  value?: string;\n  type: string;\n  disabled?: boolean;\n  ref: React.RefObject<HTMLInputElement | null>;\n  placeholder?: string | undefined;\n};\n\nconst TypeaheadInput: IStyledComponent<'web', TypeaheadInputProps> = styled.input.withConfig({\n  shouldForwardProp\n})<TypeaheadInputProps>`\n  ${props => (props.light ? props.theme.inputLT : props.theme.secondaryInput)}\n  &:hover {\n    cursor: pointer;\n    background-color: ${props =>\n      props.light ? props.theme.selectBackgroundLT : props.theme.secondaryInputBgd};\n  }\n`;\n\nconst InputIcon = styled.div.attrs({\n  className: 'typeahead__input_icon'\n})`\n  position: absolute;\n  right: 15px;\n  top: 14px;\n  color: ${props => props.theme.inputPlaceholderColor};\n`;\n\nfunction generateSearchFunction(props: TypeaheadProps) {\n  const {searchOptions, filterOption} = props;\n  if (typeof searchOptions === 'function') {\n    if (filterOption !== null) {\n      Console.warn('searchOptions prop is being used, filterOption prop will be ignored');\n    }\n    return searchOptions;\n  } else if (typeof filterOption === 'function') {\n    // use custom filter option\n    return (value, options) => options.filter(o => filterOption(value, o));\n  }\n\n  const mapper =\n    typeof filterOption === 'string'\n      ? Accessor.generateAccessor(filterOption)\n      : Accessor.IDENTITY_FN;\n\n  return (value, options) => {\n    return fuzzy.filter(value, options, {extract: mapper}).map(res => options[res.index]);\n  };\n}\n\nfunction searchOptionsOnInput(inputValue, props) {\n  const searchOptions = generateSearchFunction(props);\n  return searchOptions(inputValue, props.options);\n}\n\nfunction getOptionsForValue(value, props, state) {\n  const {options, showOptionsWhenEmpty} = props;\n\n  if (!props.searchable) {\n    // directly pass through options if can not be searched\n    return options;\n  }\n  if (shouldSkipSearch(value, state, showOptionsWhenEmpty)) {\n    return options;\n  }\n\n  const searchOptions = generateSearchFunction(props);\n  return searchOptions(value, options);\n}\n\nfunction shouldSkipSearch(input, state, showOptionsWhenEmpty) {\n  const emptyValue = !input || input.trim().length === 0;\n\n  // this.state must be checked because it may not be defined yet if this function\n  // is called from within getInitialState\n  const isFocused = state && state.isFocused;\n  return !(showOptionsWhenEmpty && isFocused) && emptyValue;\n}\n\ntype Option = string | number | boolean | object | undefined;\ninterface TypeaheadProps {\n  name?: string;\n  customClasses?: any;\n  resultsTruncatedMessage?: string;\n  options?: ReadonlyArray<Option>;\n  fixedOptions?: ReadonlyArray<Option> | null;\n  allowCustomValues?: number;\n  initialValue?: string;\n  value?: string;\n  placeholder?: string;\n  disabled?: boolean;\n  textarea?: boolean;\n  inputProps?: object;\n  onOptionSelected?: (option: any, event: any) => any;\n  onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;\n  onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;\n  onKeyPress?: KeyboardEventHandler<HTMLDivElement>;\n  onKeyUp?: KeyboardEventHandler<HTMLDivElement>;\n  onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;\n  onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;\n  filterOption?: string | ((o: Option, s: string) => boolean);\n  searchOptions?: (o: Option, s: string) => boolean;\n  displayOption?: string | ((o: Option) => string);\n  inputDisplayOption?: string | ((o: Option) => string);\n  formInputOption?: string | ((o: Option) => string);\n  defaultClassNames?: boolean;\n  customListComponent?: ElementType;\n  customListItemComponent?: ElementType;\n  customListHeaderComponent?: ElementType | null;\n  showOptionsWhenEmpty?: boolean;\n  searchable?: boolean;\n  light?: boolean;\n  inputIcon: ElementType;\n  className?: string;\n  selectedItems?: any[] | null;\n  autoFocus: boolean;\n  // deprecated\n  maxVisible?: number;\n}\n\ninterface TypeaheadState {\n  searchResults: ReadonlyArray<string | number | boolean | object | undefined>;\n\n  // This should be called something else, 'entryValue'\n  entryValue?: string;\n\n  // A valid typeahead value\n  selection?: string;\n\n  // Index of the selection\n  selectionIndex: null;\n\n  // Keep track of the focus state of the input element, to determine\n  // whether to show options when empty (if showOptionsWhenEmpty is true)\n  isFocused: boolean;\n}\n\nfunction noop() {\n  return;\n}\nclass Typeahead extends Component<TypeaheadProps, TypeaheadState> {\n  static defaultProps = {\n    options: [],\n    customClasses: {\n      results: 'list-selector',\n      input: 'typeahead__input',\n      listItem: 'list__item',\n      listAnchor: 'list__item__anchor'\n    },\n    allowCustomValues: 0,\n    initialValue: '',\n    value: '',\n    placeholder: '',\n    disabled: false,\n    textarea: false,\n    inputProps: {},\n    onOptionSelected: noop,\n    onChange: noop,\n    onKeyDown: noop,\n    onKeyPress: noop,\n    onKeyUp: noop,\n    onFocus: noop,\n    onBlur: noop,\n    filterOption: null,\n    searchOptions: null,\n    inputDisplayOption: null,\n    defaultClassNames: true,\n    customListComponent: DropdownList,\n    customListItemComponent: ListItem,\n    inputIcon: Search,\n    customListHeaderComponent: null,\n    showOptionsWhenEmpty: true,\n    searchable: true,\n    resultsTruncatedMessage: null,\n    autoFocus: true\n  };\n\n  static getDerivedStateFromProps(props, state) {\n    if (props.options === state.prevOptions) {\n      return {};\n    }\n\n    //  invoked after a component is instantiated as well as before it is re-rendered\n    const searchResults = getOptionsForValue(state.entryValue, props, state);\n\n    return {\n      searchResults,\n      prevOptions: props.options\n    };\n  }\n\n  constructor(props) {\n    super(props);\n\n    this.state = {\n      // initiate searchResults with options\n      searchResults: this.props.options || [],\n\n      // This should be called something else, 'entryValue'\n      entryValue: this.props.value || this.props.initialValue,\n\n      // A valid typeahead value\n      selection: this.props.value,\n\n      // Index of the selection\n      selectionIndex: null,\n\n      // Keep track of the focus state of the input element, to determine\n      // whether to show options when empty (if showOptionsWhenEmpty is true)\n      isFocused: false\n    };\n  }\n\n  componentDidMount() {\n    // call focus on entry or div to trigger key events listener\n    if (this.props.autoFocus) {\n      if (this.entry.current) {\n        this.entry.current.focus();\n      } else {\n        this.root.current?.focus();\n      }\n    }\n  }\n\n  root = createRef<HTMLDivElement | null>();\n  entry = createRef<HTMLInputElement | null>();\n\n  focus = () => {\n    if (this.entry.current) {\n      this.entry.current.focus();\n    }\n  };\n\n  _hasCustomValue = () => {\n    return (\n      Number(this.props.allowCustomValues) > 0 &&\n      Number(this.state.entryValue?.length) >= Number(this.props.allowCustomValues) &&\n      this.state.searchResults.indexOf(this.state.entryValue) < 0\n    );\n  };\n\n  _getCustomValue = () => {\n    return this._hasCustomValue() ? this.state.entryValue : null;\n  };\n\n  _renderIncrementalSearchResults() {\n    const {customListComponent: CustomListComponent = DropdownList} = this.props;\n    return (\n      <CustomListComponent\n        fixedOptions={this.props.fixedOptions}\n        options={this.state.searchResults}\n        areResultsTruncated={false}\n        resultsTruncatedMessage={this.props.resultsTruncatedMessage}\n        onOptionSelected={this._onOptionSelected}\n        allowCustomValues={this.props.allowCustomValues}\n        customValue={this._getCustomValue()}\n        customClasses={this.props.customClasses}\n        customListItemComponent={this.props.customListItemComponent}\n        customListHeaderComponent={this.props.customListHeaderComponent}\n        selectionIndex={this.state.selectionIndex}\n        defaultClassNames={this.props.defaultClassNames}\n        displayOption={this.props.displayOption}\n        selectedItems={this.props.selectedItems}\n        light={this.props.light}\n      />\n    );\n  }\n\n  getSelection() {\n    let index: number | null = this.state.selectionIndex;\n    if (index === null) {\n      return null;\n    }\n    index = Number(index);\n\n    if (this._hasCustomValue()) {\n      if (index === 0) {\n        return this.state.entryValue;\n      }\n      index--;\n    }\n    if (this._hasFixedOptions()) {\n      return index < Number(this.props.fixedOptions?.length)\n        ? this.props.fixedOptions?.[index]\n        : this.state.searchResults[index - Number(this.props.fixedOptions?.length)];\n    }\n    return this.state.searchResults[index];\n  }\n\n  _onOptionSelected = (option, event) => {\n    if (this.props.searchable) {\n      // reset entry input\n      this.setState({\n        // reset search options when selection has been made\n        searchResults: this.props.options || [],\n        selection: '',\n        entryValue: ''\n      });\n    }\n\n    this.props.onOptionSelected?.(option, event);\n  };\n\n  // use () => {} to avoid binding 'this'\n  _onTextEntryUpdated = () => {\n    if (this.props.searchable) {\n      const value = this.entry.current?.value;\n\n      this.setState({\n        searchResults: searchOptionsOnInput(value, this.props),\n        selection: '',\n        entryValue: value\n      });\n    }\n  };\n\n  _onEnter = event => {\n    const selection = this.getSelection();\n    if (!selection) {\n      this.props.onKeyDown?.(event);\n    }\n    this._onOptionSelected(selection, event);\n  };\n\n  _onEscape = () => {\n    this.setState({\n      selectionIndex: null\n    });\n  };\n\n  _onTab = event => {\n    const selection = this.getSelection();\n    let option = selection\n      ? selection\n      : this.state.searchResults.length > 0\n      ? this.state.searchResults[0]\n      : null;\n\n    if (option === null && this._hasCustomValue()) {\n      option = this._getCustomValue();\n    }\n\n    if (option !== null) {\n      return this._onOptionSelected(option, event);\n    }\n  };\n\n  eventMap = () => {\n    const events = {};\n\n    events[KeyEvent.DOM_VK_UP] = this.navUp;\n    events[KeyEvent.DOM_VK_DOWN] = this.navDown;\n    events[KeyEvent.DOM_VK_RETURN] = events[KeyEvent.DOM_VK_ENTER] = this._onEnter;\n    events[KeyEvent.DOM_VK_ESCAPE] = this._onEscape;\n    events[KeyEvent.DOM_VK_TAB] = this._onTab;\n\n    return events;\n  };\n\n  _nav = delta => {\n    if (!this._hasHint()) {\n      return;\n    }\n    let newIndex =\n      this.state.selectionIndex === null\n        ? delta === 1\n          ? 0\n          : delta\n        : this.state.selectionIndex + delta;\n    let length = this.props.maxVisible\n      ? this.state.searchResults.slice(0, this.props.maxVisible).length\n      : this.state.searchResults.length;\n    if (this._hasCustomValue()) {\n      length += 1;\n    }\n\n    if (newIndex < 0) {\n      newIndex += length;\n    } else if (newIndex >= length) {\n      newIndex -= length;\n    }\n\n    this.setState({selectionIndex: newIndex});\n  };\n\n  navDown = () => {\n    this._nav(1);\n  };\n\n  navUp = () => {\n    this._nav(-1);\n  };\n\n  _onChange: React.ChangeEventHandler<HTMLInputElement> = event => {\n    if (this.props.onChange) {\n      this.props.onChange(event);\n    }\n\n    this._onTextEntryUpdated();\n  };\n\n  _onKeyDown: React.KeyboardEventHandler<HTMLDivElement> = event => {\n    // If there are no visible elements, don't perform selector navigation.\n    // Just pass this up to the upstream onKeydown handler.\n    // Also skip if the user is pressing the shift key, since none of our handlers are looking for shift\n    if (!this._hasHint() || event.shiftKey) {\n      return this.props.onKeyDown?.(event);\n    }\n\n    const handler = this.eventMap()[event.keyCode];\n\n    if (handler) {\n      handler(event);\n    } else {\n      return this.props.onKeyDown?.(event);\n    }\n    // Don't propagate the keystroke back to the DOM/browser\n    event.preventDefault();\n  };\n\n  _onFocus: React.FocusEventHandler<HTMLDivElement> = event => {\n    this.setState({isFocused: true});\n    if (this.props.onFocus) {\n      return this.props.onFocus(event);\n    }\n  };\n\n  _onBlur: React.FocusEventHandler<HTMLInputElement> = event => {\n    this.setState({isFocused: false});\n    if (this.props.onBlur) {\n      return this.props.onBlur(event);\n    }\n  };\n\n  _renderHiddenInput() {\n    if (!this.props.name) {\n      return null;\n    }\n\n    return <input type=\"hidden\" name={this.props.name} value={this.state.selection} />;\n  }\n\n  _hasHint() {\n    return this.state.searchResults.length > 0 || this._hasCustomValue();\n  }\n\n  _hasFixedOptions() {\n    return Array.isArray(this.props.fixedOptions) && this.props.fixedOptions.length;\n  }\n\n  render() {\n    const inputClasses = {};\n    inputClasses[this.props.customClasses?.input] = Boolean(this.props.customClasses?.input);\n    const inputClassList = classNames(inputClasses);\n\n    const classes = {\n      [DEFAULT_CLASS]: this.props.defaultClassNames\n    };\n    classes[this.props.className ? this.props.className : ''] = Boolean(this.props.className);\n    const classList = classNames(classes);\n\n    return (\n      <TypeaheadWrapper\n        className={classList}\n        ref={this.root}\n        tabIndex={0}\n        onKeyDown={this._onKeyDown}\n        onKeyPress={this.props.onKeyPress}\n        onKeyUp={this.props.onKeyUp}\n        onFocus={this._onFocus}\n        light={this.props.light}\n      >\n        {this._renderHiddenInput()}\n        {this.props.searchable ? (\n          <InputBox>\n            <TypeaheadInput\n              ref={this.entry}\n              type=\"text\"\n              disabled={this.props.disabled}\n              {...this.props.inputProps}\n              placeholder={this.props.placeholder}\n              className={inputClassList}\n              value={this.state.entryValue}\n              onChange={this._onChange}\n              onBlur={this._onBlur}\n              light={this.props.light}\n            />\n            <InputIcon>\n              <this.props.inputIcon height=\"18px\" />\n            </InputIcon>\n          </InputBox>\n        ) : null}\n        {this._renderIncrementalSearchResults()}\n      </TypeaheadWrapper>\n    );\n  }\n}\n\nexport default Typeahead;\n"],"mappings":"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","ignoreList":[]}