@kepler.gl/components 3.1.0-alpha.1 → 3.1.0-alpha.3

package/dist/common/item-selector/dropdown-select.d.ts

@@ -0,0 +1,33 @@
+import React, { ComponentType } from 'react';
+export declare type ListItemProps<Option> = {
+    value: Option;
+    displayOption: (opt: Option) => string;
+    light: boolean;
+    disabled: boolean;
+};
+export declare type DropdownSelectProps<Option> = {
+    className?: string;
+    displayOption?: string | ((opt: Option) => string);
+    disabled?: boolean;
+    onClick: (e: React.MouseEvent) => void;
+    inputTheme?: string;
+    error?: boolean;
+    size?: string;
+    value: Option;
+    placeholder?: string;
+    erasable?: boolean;
+    showArrow?: boolean;
+    onErase?: (e: React.MouseEvent) => void;
+    showDropdown: (e: React.MouseEvent) => void;
+    DropDownLineItemRenderComponent?: ComponentType<ListItemProps<Option>>;
+};
+export declare const StyledDropdownSelect: import("styled-components").StyledComponent<"div", any, {
+    size: DropdownSelectProps<any>['size'];
+    inputTheme: DropdownSelectProps<any>['inputTheme'];
+}, never>;
+export declare const DropdownSelectValue: import("styled-components").StyledComponent<"span", any, {
+    inputTheme: DropdownSelectProps<any>['inputTheme'];
+    hasPlaceholder: boolean;
+}, never>;
+declare function DropdownSelect<Option>({ className, displayOption, disabled, onClick, inputTheme, size, value, placeholder, erasable, showArrow, onErase, showDropdown, DropDownLineItemRenderComponent }: DropdownSelectProps<Option>): JSX.Element;
+export default DropdownSelect;

package/dist/common/item-selector/dropdown-select.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.StyledDropdownSelect = exports.DropdownSelectValue = void 0;
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireDefault(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _commonUtils = require("@kepler.gl/common-utils");
+var _localization = require("@kepler.gl/localization");
+var _icons = require("../icons");
+var _dropdownList = require("./dropdown-list");
+var _templateObject, _templateObject2, _templateObject3; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var StyledDropdownSelect = exports.StyledDropdownSelect = _styledComponents["default"].div.attrs({
+  className: 'item-selector__dropdown'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  ", ";\n\n  height: ", ";\n\n  .list__item__anchor {\n    ", ";\n  }\n"])), function (props) {
+  return props.inputTheme === 'secondary' ? props.theme.secondaryInput : props.inputTheme === 'light' ? props.theme.inputLT : props.theme.input;
+}, function (props) {
+  return props.size === 'small' ? props.theme.inputBoxHeightSmall : props.theme.inputBoxHeight;
+}, function (props) {
+  return props.theme.dropdownListAnchor;
+});
+var DropdownSelectValue = exports.DropdownSelectValue = _styledComponents["default"].span(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  color: ", ";\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n\n  .list__item {\n    ", ";\n  }\n\n  .list__item__anchor {\n    ", ";\n  }\n"])), function (props) {
+  return props.hasPlaceholder && props.inputTheme === 'light' ? props.theme.selectColorPlaceHolderLT : props.hasPlaceholder ? props.theme.selectColorPlaceHolder : props.inputTheme === 'light' ? props.theme.selectColorLT : props.theme.selectColor;
+}, function (props) {
+  return props.inputTheme === 'light' ? props.theme.dropdownListItemLT : props.theme.dropdownListItem;
+}, function (props) {
+  return props.inputTheme === 'light' ? props.theme.dropdownListAnchorLT : props.theme.dropdownListAnchor;
+});
+var DropdownSelectActionRight = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  margin-right: 2px;\n  display: flex;\n  color: ", ";\n\n  :hover {\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.subtextColor;
+}, function (props) {
+  return props.theme.textColor;
+});
+function DropdownSelect(_ref) {
+  var className = _ref.className,
+    displayOption = _ref.displayOption,
+    disabled = _ref.disabled,
+    onClick = _ref.onClick,
+    inputTheme = _ref.inputTheme,
+    size = _ref.size,
+    value = _ref.value,
+    placeholder = _ref.placeholder,
+    erasable = _ref.erasable,
+    showArrow = _ref.showArrow,
+    onErase = _ref.onErase,
+    showDropdown = _ref.showDropdown,
+    _ref$DropDownLineItem = _ref.DropDownLineItemRenderComponent,
+    DropDownLineItemRenderComponent = _ref$DropDownLineItem === void 0 ? _dropdownList.ListItem : _ref$DropDownLineItem;
+  var hasValue = (0, _commonUtils.notNullorUndefined)(value);
+  return /*#__PURE__*/_react["default"].createElement(StyledDropdownSelect, {
+    className: className,
+    onClick: onClick,
+    inputTheme: inputTheme,
+    size: size
+  }, /*#__PURE__*/_react["default"].createElement(DropdownSelectValue, {
+    hasPlaceholder: !hasValue,
+    inputTheme: inputTheme,
+    className: "item-selector__dropdown__value"
+  }, hasValue ? /*#__PURE__*/_react["default"].createElement(DropDownLineItemRenderComponent, {
+    displayOption: displayOption,
+    value: value,
+    disabled: Boolean(disabled),
+    light: inputTheme === 'light'
+  }) : /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: placeholder || 'placeholder.selectValue'
+  })), erasable && hasValue ? /*#__PURE__*/_react["default"].createElement(DropdownSelectActionRight, null, /*#__PURE__*/_react["default"].createElement(_icons.Delete, {
+    height: "12px",
+    onClick: onErase
+  })) : showArrow ? /*#__PURE__*/_react["default"].createElement(DropdownSelectActionRight, null, /*#__PURE__*/_react["default"].createElement(_icons.ArrowDown, {
+    height: "14px",
+    onClick: showDropdown
+  })) : null);
+}
+var _default = exports["default"] = DropdownSelect;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_styledComponents","_commonUtils","_localization","_icons","_dropdownList","_templateObject","_templateObject2","_templateObject3","StyledDropdownSelect","exports","styled","div","attrs","className","_taggedTemplateLiteral2","props","inputTheme","theme","secondaryInput","inputLT","input","size","inputBoxHeightSmall","inputBoxHeight","dropdownListAnchor","DropdownSelectValue","span","hasPlaceholder","selectColorPlaceHolderLT","selectColorPlaceHolder","selectColorLT","selectColor","dropdownListItemLT","dropdownListItem","dropdownListAnchorLT","DropdownSelectActionRight","subtextColor","textColor","DropdownSelect","_ref","displayOption","disabled","onClick","value","placeholder","erasable","showArrow","onErase","showDropdown","_ref$DropDownLineItem","DropDownLineItemRenderComponent","ListItem","hasValue","notNullorUndefined","createElement","Boolean","light","FormattedMessage","id","Delete","height","ArrowDown","_default"],"sources":["../../../src/common/item-selector/dropdown-select.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {ComponentType} from 'react';\nimport styled from 'styled-components';\n\nimport {notNullorUndefined} from '@kepler.gl/common-utils';\nimport {FormattedMessage} from '@kepler.gl/localization';\n\nimport {ArrowDown, Delete} from '../icons';\nimport {ListItem} from './dropdown-list';\n\nexport type ListItemProps<Option> = {\n  value: Option;\n  displayOption: (opt: Option) => string;\n  light: boolean;\n  disabled: boolean;\n};\n\nexport type DropdownSelectProps<Option> = {\n  className?: string;\n  displayOption?: string | ((opt: Option) => string);\n  disabled?: boolean;\n  onClick: (e: React.MouseEvent) => void;\n  inputTheme?: string;\n  error?: boolean;\n  size?: string;\n  value: Option;\n  placeholder?: string;\n  erasable?: boolean;\n  showArrow?: boolean;\n  onErase?: (e: React.MouseEvent) => void;\n  showDropdown: (e: React.MouseEvent) => void;\n  DropDownLineItemRenderComponent?: ComponentType<ListItemProps<Option>>;\n};\n\nexport const StyledDropdownSelect = styled.div.attrs<{className?: string}>({\n  className: 'item-selector__dropdown'\n})<{\n  size: DropdownSelectProps<any>['size'];\n  inputTheme: DropdownSelectProps<any>['inputTheme'];\n}>`\n  ${props =>\n    props.inputTheme === 'secondary'\n      ? props.theme.secondaryInput\n      : props.inputTheme === 'light'\n      ? props.theme.inputLT\n      : props.theme.input};\n\n  height: ${props =>\n    props.size === 'small' ? props.theme.inputBoxHeightSmall : props.theme.inputBoxHeight};\n\n  .list__item__anchor {\n    ${props => props.theme.dropdownListAnchor};\n  }\n`;\n\nexport const DropdownSelectValue = styled.span<{\n  inputTheme: DropdownSelectProps<any>['inputTheme'];\n  hasPlaceholder: boolean;\n}>`\n  color: ${props =>\n    props.hasPlaceholder && props.inputTheme === 'light'\n      ? props.theme.selectColorPlaceHolderLT\n      : props.hasPlaceholder\n      ? props.theme.selectColorPlaceHolder\n      : props.inputTheme === 'light'\n      ? props.theme.selectColorLT\n      : props.theme.selectColor};\n  overflow: hidden;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n\n  .list__item {\n    ${props =>\n      props.inputTheme === 'light' ? props.theme.dropdownListItemLT : props.theme.dropdownListItem};\n  }\n\n  .list__item__anchor {\n    ${props =>\n      props.inputTheme === 'light'\n        ? props.theme.dropdownListAnchorLT\n        : props.theme.dropdownListAnchor};\n  }\n`;\n\nconst DropdownSelectActionRight = styled.div`\n  margin-right: 2px;\n  display: flex;\n  color: ${props => props.theme.subtextColor};\n\n  :hover {\n    color: ${props => props.theme.textColor};\n  }\n`;\n\nfunction DropdownSelect<Option>({\n  // dropdownSelectProps,\n  className,\n  displayOption,\n  disabled,\n  onClick,\n  inputTheme,\n  size,\n  value,\n  placeholder,\n  erasable,\n  showArrow,\n  onErase,\n  showDropdown,\n  DropDownLineItemRenderComponent = ListItem\n}: DropdownSelectProps<Option>): JSX.Element {\n  const hasValue = notNullorUndefined(value);\n\n  return (\n    <StyledDropdownSelect\n      className={className}\n      onClick={onClick}\n      inputTheme={inputTheme}\n      size={size}\n    >\n      <DropdownSelectValue\n        hasPlaceholder={!hasValue}\n        inputTheme={inputTheme}\n        className=\"item-selector__dropdown__value\"\n      >\n        {hasValue ? (\n          <DropDownLineItemRenderComponent\n            displayOption={displayOption as ListItemProps<any>['displayOption']}\n            value={value}\n            disabled={Boolean(disabled)}\n            light={inputTheme === 'light'}\n          />\n        ) : (\n          <FormattedMessage id={placeholder || 'placeholder.selectValue'} />\n        )}\n      </DropdownSelectValue>\n      {erasable && hasValue ? (\n        <DropdownSelectActionRight>\n          <Delete height=\"12px\" onClick={onErase} />\n        </DropdownSelectActionRight>\n      ) : showArrow ? (\n        <DropdownSelectActionRight>\n          <ArrowDown height=\"14px\" onClick={showDropdown} />\n        </DropdownSelectActionRight>\n      ) : null}\n    </StyledDropdownSelect>\n  );\n}\n\nexport default DropdownSelect;\n"],"mappings":"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","ignoreList":[]}

package/dist/common/item-selector/item-selector.d.ts

@@ -0,0 +1,82 @@
+import React, { Component, ComponentType, MouseEventHandler, RefObject } from 'react';
+import DropdownList from './dropdown-list';
+import { IntlShape } from 'react-intl';
+import { ListItemProps } from './dropdown-select';
+interface DropdownWrapperProps {
+    placement?: string;
+    width: number;
+}
+export declare type ItemSelectorProps<Option> = {
+    selectedItems?: ReadonlyArray<Option> | string | number | boolean | object | null;
+    options: ReadonlyArray<Option>;
+    onChange: (items: ReadonlyArray<Option> | string | number | boolean | object | null) => void;
+    fixedOptions?: ReadonlyArray<Option> | null;
+    erasable?: boolean;
+    showArrow?: boolean;
+    searchOptions?: (value: any, opt: Option) => any;
+    searchable?: boolean;
+    displayOption?: string | ((opt: Option) => string);
+    getOptionValue?: string | ((opt: Option) => any);
+    filterOption?: string | ((opt: Option) => boolean);
+    placement?: string;
+    disabled?: boolean;
+    isError?: boolean;
+    multiSelect?: boolean;
+    inputTheme?: string;
+    onOpen?: () => void;
+    size?: string;
+    onBlur?: () => void;
+    placeholder?: string;
+    closeOnSelect?: boolean;
+    typeaheadPlaceholder?: string;
+    DropDownWrapperComponent?: ComponentType<any> | null;
+    DropdownHeaderComponent?: ComponentType<any> | null;
+    DropDownRenderComponent?: ComponentType<any>;
+    DropDownLineItemRenderComponent?: ComponentType<ListItemProps<Option>>;
+    CustomChickletComponent?: ComponentType<any>;
+    intl: IntlShape;
+    className?: string;
+    reorderItems?: (newOrder: any) => void;
+    showDropdownOnMount?: boolean;
+};
+declare class ItemSelectorUnmemoized extends Component<ItemSelectorProps<any>> {
+    static defaultProps: {
+        multiSelect: boolean;
+        placeholder: string;
+        closeOnSelect: boolean;
+        searchable: boolean;
+        DropDownRenderComponent: typeof DropdownList;
+        DropDownLineItemRenderComponent: ({ value, displayOption, disabled, light }: {
+            value: any;
+            displayOption?: ((d: any) => any) | undefined;
+            disabled: any;
+            light: any;
+        }) => React.JSX.Element;
+        DropDownWrapperComponent: import("styled-components").StyledComponent<"div", any, DropdownWrapperProps, never>;
+        reorderItems: undefined;
+        className: string;
+    };
+    state: {
+        showTypeahead: boolean;
+        dimensions: {
+            width: number;
+        };
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    root: RefObject<HTMLDivElement>;
+    handleClickOutside: () => void;
+    _handleResize: (dimensions: any) => void;
+    _hideTypeahead: () => void;
+    _onBlur: () => void;
+    _removeItem: (item: any, e: any) => void;
+    _selectItem: (item: any) => void;
+    _onErase: MouseEventHandler;
+    _showTypeahead: MouseEventHandler;
+    _renderDropdown(intl: IntlShape): React.JSX.Element;
+    render(): React.JSX.Element;
+}
+declare const _default: React.FC<import("react-intl").WithIntlProps<ItemSelectorProps<any> & React.RefAttributes<ItemSelectorUnmemoized>>> & {
+    WrappedComponent: React.ComponentType<ItemSelectorProps<any> & React.RefAttributes<ItemSelectorUnmemoized>>;
+};
+export default _default;

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

@@ -0,0 +1,252 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _lodash = _interopRequireDefault(require("lodash.uniqby"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _accessor = _interopRequireDefault(require("./accessor"));
+var _chickletedInput = _interopRequireDefault(require("./chickleted-input"));
+var _typeahead = _interopRequireDefault(require("./typeahead"));
+var _dropdownList = _interopRequireWildcard(require("./dropdown-list"));
+var _portaled = _interopRequireDefault(require("../../common/portaled"));
+var _utils = require("@kepler.gl/utils");
+var _commonUtils = require("@kepler.gl/common-utils");
+var _reactIntl = require("react-intl");
+var _dropdownSelect = _interopRequireDefault(require("./dropdown-select"));
+var _templateObject; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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; })(); }
+var DropdownWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ", ";\n  width: ", "px;\n"])), function (props) {
+  return props.theme.dropdownWrapperZ;
+}, function (props) {
+  return props.width;
+});
+var ItemSelectorUnmemoized = /*#__PURE__*/function (_Component) {
+  function ItemSelectorUnmemoized() {
+    var _this;
+    (0, _classCallCheck2["default"])(this, ItemSelectorUnmemoized);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, ItemSelectorUnmemoized, [].concat(args));
+    (0, _defineProperty2["default"])(_this, "state", {
+      showTypeahead: false,
+      dimensions: {
+        width: 200
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "root", /*#__PURE__*/(0, _react.createRef)());
+    (0, _defineProperty2["default"])(_this, "handleClickOutside", function () {
+      _this._hideTypeahead();
+    });
+    (0, _defineProperty2["default"])(_this, "_handleResize", function (dimensions) {
+      _this.setState({
+        dimensions: dimensions
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "_hideTypeahead", function () {
+      _this.setState({
+        showTypeahead: false
+      });
+      _this._onBlur();
+    });
+    (0, _defineProperty2["default"])(_this, "_onBlur", function () {
+      // note: chickleted input is not a real form element so we call onBlur()
+      // when we feel the events are appropriate
+      if (_this.props.onBlur) {
+        _this.props.onBlur();
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_removeItem", function (item, e) {
+      // only used when multiSelect = true
+      e.preventDefault();
+      e.stopPropagation();
+      var multiSelectedItems = (0, _commonUtils.toArray)(_this.props.selectedItems);
+      var index = multiSelectedItems.findIndex(function (t) {
+        return t === item;
+      });
+      if (index < 0) {
+        return;
+      }
+      var items = [].concat((0, _toConsumableArray2["default"])(multiSelectedItems.slice(0, index)), (0, _toConsumableArray2["default"])(multiSelectedItems.slice(index + 1, multiSelectedItems.length)));
+      _this.props.onChange(items);
+      if (_this.props.closeOnSelect) {
+        _this.setState({
+          showTypeahead: false
+        });
+        _this._onBlur();
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_selectItem", function (item) {
+      var getValue = _accessor["default"].generateOptionToStringFor(_this.props.getOptionValue || _this.props.displayOption);
+      var previousSelected = (0, _commonUtils.toArray)(_this.props.selectedItems);
+      if (_this.props.multiSelect) {
+        var items = (0, _lodash["default"])(previousSelected.concat((0, _commonUtils.toArray)(item)), getValue);
+        _this.props.onChange(items);
+      } else {
+        _this.props.onChange(getValue(item));
+      }
+      if (_this.props.closeOnSelect) {
+        _this.setState({
+          showTypeahead: false
+        });
+        _this._onBlur();
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onErase", function (e) {
+      e.stopPropagation();
+      _this.props.onChange(null);
+    });
+    (0, _defineProperty2["default"])(_this, "_showTypeahead", function (e) {
+      e.stopPropagation();
+      if (!_this.props.disabled) {
+        if (_this.props.onOpen) {
+          _this.props.onOpen();
+        }
+        _this.setState({
+          showTypeahead: true
+        });
+      }
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(ItemSelectorUnmemoized, _Component);
+  return (0, _createClass2["default"])(ItemSelectorUnmemoized, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.showDropdownOnMount) {
+        this.setState({
+          showTypeahead: true
+        });
+      }
+      if (this.root.current instanceof HTMLElement) {
+        (0, _utils.observeDimensions)(this.root.current, this._handleResize);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.root.current instanceof HTMLElement) {
+        (0, _utils.unobserveDimensions)(this.root.current);
+      }
+    }
+  }, {
+    key: "_renderDropdown",
+    value: function _renderDropdown(intl) {
+      var _this$props$placement = this.props.placement,
+        placement = _this$props$placement === void 0 ? 'bottom' : _this$props$placement;
+      var dimensions = this.state.dimensions;
+      var DropDownWrapperComponent = this.props.DropDownWrapperComponent;
+      return /*#__PURE__*/_react["default"].createElement(_portaled["default"], {
+        left: 0,
+        top: 0,
+        isOpened: this.state.showTypeahead,
+        onClose: this._hideTypeahead
+      }, /*#__PURE__*/_react["default"].createElement(DropDownWrapperComponent, {
+        placement: placement,
+        width: dimensions === null || dimensions === void 0 ? void 0 : dimensions.width
+      }, /*#__PURE__*/_react["default"].createElement(_typeahead["default"], {
+        customClasses: {
+          results: 'list-selector',
+          input: 'typeahead__input',
+          listItem: 'list__item',
+          listAnchor: 'list__item__anchor'
+        },
+        options: this.props.options,
+        filterOption: this.props.filterOption,
+        fixedOptions: this.props.fixedOptions,
+        placeholder: this.props.typeaheadPlaceholder || intl ? intl.formatMessage({
+          id: 'placeholder.search'
+        }) : 'Search',
+        onOptionSelected: this._selectItem,
+        customListComponent: this.props.DropDownRenderComponent,
+        customListHeaderComponent: this.props.DropdownHeaderComponent,
+        customListItemComponent: this.props.DropDownLineItemRenderComponent,
+        displayOption: _accessor["default"].generateOptionToStringFor(this.props.displayOption),
+        searchable: this.props.searchable,
+        searchOptions: this.props.searchOptions,
+        showOptionsWhenEmpty: true,
+        selectedItems: (0, _commonUtils.toArray)(this.props.selectedItems),
+        light: this.props.inputTheme === 'light'
+      })));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var selected = (0, _commonUtils.toArray)(this.props.selectedItems);
+      var displayOption = _accessor["default"].generateOptionToStringFor(this.props.displayOption);
+      var _this$props = this.props,
+        disabled = _this$props.disabled,
+        _this$props$inputThem = _this$props.inputTheme,
+        inputTheme = _this$props$inputThem === void 0 ? 'primary' : _this$props$inputThem;
+      var dropdownSelectProps = {
+        className: (0, _classnames["default"])({
+          active: this.state.showTypeahead
+        }),
+        displayOption: displayOption,
+        disabled: disabled,
+        onClick: this._showTypeahead,
+        error: this.props.isError,
+        inputTheme: inputTheme,
+        size: this.props.size
+      };
+      var intl = this.props.intl;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: (0, _classnames["default"])('item-selector', this.props.className),
+        ref: this.root
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        style: {
+          position: 'relative'
+        }
+      }, this.props.multiSelect ? /*#__PURE__*/_react["default"].createElement(_chickletedInput["default"], (0, _extends2["default"])({}, dropdownSelectProps, {
+        selectedItems: (0, _commonUtils.toArray)(this.props.selectedItems),
+        placeholder: this.props.placeholder,
+        removeItem: this._removeItem,
+        reorderItems: this.props.reorderItems,
+        CustomChickletComponent: this.props.CustomChickletComponent,
+        inputTheme: inputTheme
+      })) : /*#__PURE__*/_react["default"].createElement(_dropdownSelect["default"], (0, _extends2["default"])({}, dropdownSelectProps, {
+        value: selected[0],
+        placeholder: this.props.placeholder,
+        erasable: this.props.erasable,
+        showArrow: this.props.showArrow,
+        onErase: this._onErase,
+        showDropdown: this._showTypeahead,
+        DropDownLineItemRenderComponent: this.props.DropDownLineItemRenderComponent
+      })), this._renderDropdown(intl)));
+    }
+  }]);
+}(_react.Component);
+(0, _defineProperty2["default"])(ItemSelectorUnmemoized, "defaultProps", {
+  multiSelect: true,
+  placeholder: 'placeholder.enterValue',
+  closeOnSelect: true,
+  searchable: true,
+  DropDownRenderComponent: _dropdownList["default"],
+  DropDownLineItemRenderComponent: _dropdownList.ListItem,
+  DropDownWrapperComponent: DropdownWrapper,
+  reorderItems: undefined,
+  className: ''
+});
+var ItemSelector = /*#__PURE__*/_react["default"].memo(ItemSelectorUnmemoized);
+ItemSelector.displayName = 'ItemSelector';
+var _default = exports["default"] = (0, _reactIntl.injectIntl)(ItemSelector);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_classnames","_interopRequireDefault","_lodash","_styledComponents","_accessor","_chickletedInput","_typeahead","_dropdownList","_portaled","_utils","_commonUtils","_reactIntl","_dropdownSelect","_templateObject","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","_callSuper","o","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","apply","Boolean","prototype","valueOf","DropdownWrapper","styled","div","_taggedTemplateLiteral2","props","theme","dropdownWrapperZ","width","ItemSelectorUnmemoized","_Component","_this","_classCallCheck2","_len","arguments","length","args","Array","_key","concat","_defineProperty2","showTypeahead","dimensions","createRef","_hideTypeahead","setState","_onBlur","onBlur","item","preventDefault","stopPropagation","multiSelectedItems","toArray","selectedItems","index","findIndex","items","_toConsumableArray2","slice","onChange","closeOnSelect","getValue","Accessor","generateOptionToStringFor","getOptionValue","displayOption","previousSelected","multiSelect","uniqBy","disabled","onOpen","_inherits2","_createClass2","key","value","componentDidMount","showDropdownOnMount","root","current","HTMLElement","observeDimensions","_handleResize","componentWillUnmount","unobserveDimensions","_renderDropdown","intl","_this$props$placement","placement","state","DropDownWrapperComponent","createElement","left","top","isOpened","onClose","customClasses","results","input","listItem","listAnchor","options","filterOption","fixedOptions","placeholder","typeaheadPlaceholder","formatMessage","id","onOptionSelected","_selectItem","customListComponent","DropDownRenderComponent","customListHeaderComponent","DropdownHeaderComponent","customListItemComponent","DropDownLineItemRenderComponent","searchable","searchOptions","showOptionsWhenEmpty","light","inputTheme","render","selected","_this$props","_this$props$inputThem","dropdownSelectProps","className","classnames","active","onClick","_showTypeahead","error","isError","size","ref","style","position","_extends2","removeItem","_removeItem","reorderItems","CustomChickletComponent","erasable","showArrow","onErase","_onErase","showDropdown","Component","DropdownList","ListItem","undefined","ItemSelector","React","memo","displayName","_default","exports","injectIntl"],"sources":["../../../src/common/item-selector/item-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, createRef, ComponentType, MouseEventHandler, RefObject} from 'react';\nimport classnames from 'classnames';\nimport uniqBy from 'lodash.uniqby';\nimport styled from 'styled-components';\n\nimport Accessor from './accessor';\nimport ChickletedInput from './chickleted-input';\nimport Typeahead from './typeahead';\nimport DropdownList, {ListItem} from './dropdown-list';\nimport Portaled from '../../common/portaled';\nimport {observeDimensions, unobserveDimensions} from '@kepler.gl/utils';\nimport {toArray} from '@kepler.gl/common-utils';\nimport {injectIntl, IntlShape} from 'react-intl';\nimport {ListItemProps} from './dropdown-select';\nimport DropdownSelect from './dropdown-select';\n\ninterface DropdownWrapperProps {\n  placement?: string;\n  width: number;\n}\n\nconst DropdownWrapper = styled.div<DropdownWrapperProps>`\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ${props => props.theme.dropdownWrapperZ};\n  width: ${props => props.width}px;\n`;\n\nexport type ItemSelectorProps<Option> = {\n  selectedItems?: ReadonlyArray<Option> | string | number | boolean | object | null;\n  options: ReadonlyArray<Option>;\n  onChange: (items: ReadonlyArray<Option> | string | number | boolean | object | null) => void;\n  fixedOptions?: ReadonlyArray<Option> | null;\n  erasable?: boolean;\n  showArrow?: boolean;\n  searchOptions?: (value: any, opt: Option) => any;\n  searchable?: boolean;\n  displayOption?: string | ((opt: Option) => string);\n  getOptionValue?: string | ((opt: Option) => any);\n  filterOption?: string | ((opt: Option) => boolean);\n  placement?: string;\n  disabled?: boolean;\n  isError?: boolean;\n  multiSelect?: boolean;\n  inputTheme?: string;\n  onOpen?: () => void;\n  size?: string;\n  onBlur?: () => void;\n  placeholder?: string;\n  closeOnSelect?: boolean;\n  typeaheadPlaceholder?: string;\n  DropDownWrapperComponent?: ComponentType<any> | null;\n  DropdownHeaderComponent?: ComponentType<any> | null;\n  DropDownRenderComponent?: ComponentType<any>;\n  DropDownLineItemRenderComponent?: ComponentType<ListItemProps<Option>>;\n  CustomChickletComponent?: ComponentType<any>;\n  intl: IntlShape;\n  className?: string;\n  reorderItems?: (newOrder: any) => void;\n  showDropdownOnMount?: boolean;\n};\n\nclass ItemSelectorUnmemoized extends Component<ItemSelectorProps<any>> {\n  static defaultProps = {\n    multiSelect: true,\n    placeholder: 'placeholder.enterValue',\n    closeOnSelect: true,\n    searchable: true,\n    DropDownRenderComponent: DropdownList,\n    DropDownLineItemRenderComponent: ListItem,\n    DropDownWrapperComponent: DropdownWrapper,\n    reorderItems: undefined,\n    className: ''\n  };\n\n  state = {\n    showTypeahead: false,\n    dimensions: {\n      width: 200\n    }\n  };\n\n  componentDidMount() {\n    if (this.props.showDropdownOnMount) {\n      this.setState({showTypeahead: true});\n    }\n\n    if (this.root.current instanceof HTMLElement) {\n      observeDimensions(this.root.current, this._handleResize);\n    }\n  }\n\n  componentWillUnmount() {\n    if (this.root.current instanceof HTMLElement) {\n      unobserveDimensions(this.root.current);\n    }\n  }\n\n  root: RefObject<HTMLDivElement> = createRef();\n\n  handleClickOutside = () => {\n    this._hideTypeahead();\n  };\n\n  _handleResize = dimensions => {\n    this.setState({dimensions});\n  };\n\n  _hideTypeahead = () => {\n    this.setState({showTypeahead: false});\n    this._onBlur();\n  };\n\n  _onBlur = () => {\n    // note: chickleted input is not a real form element so we call onBlur()\n    // when we feel the events are appropriate\n    if (this.props.onBlur) {\n      this.props.onBlur();\n    }\n  };\n\n  _removeItem = (item, e) => {\n    // only used when multiSelect = true\n    e.preventDefault();\n    e.stopPropagation();\n    const multiSelectedItems = toArray(this.props.selectedItems);\n    const index = multiSelectedItems.findIndex(t => t === item);\n\n    if (index < 0) {\n      return;\n    }\n\n    const items = [\n      ...multiSelectedItems.slice(0, index),\n      ...multiSelectedItems.slice(index + 1, multiSelectedItems.length)\n    ];\n\n    this.props.onChange(items);\n\n    if (this.props.closeOnSelect) {\n      this.setState({showTypeahead: false});\n      this._onBlur();\n    }\n  };\n\n  _selectItem = item => {\n    const getValue = Accessor.generateOptionToStringFor(\n      this.props.getOptionValue || this.props.displayOption\n    );\n\n    const previousSelected = toArray(this.props.selectedItems);\n\n    if (this.props.multiSelect) {\n      const items = uniqBy(previousSelected.concat(toArray(item)), getValue);\n      this.props.onChange(items);\n    } else {\n      this.props.onChange(getValue(item));\n    }\n\n    if (this.props.closeOnSelect) {\n      this.setState({showTypeahead: false});\n      this._onBlur();\n    }\n  };\n\n  _onErase: MouseEventHandler = e => {\n    e.stopPropagation();\n    this.props.onChange(null);\n  };\n\n  _showTypeahead: MouseEventHandler = e => {\n    e.stopPropagation();\n    if (!this.props.disabled) {\n      if (this.props.onOpen) {\n        this.props.onOpen();\n      }\n      this.setState({\n        showTypeahead: true\n      });\n    }\n  };\n\n  _renderDropdown(intl: IntlShape) {\n    const {placement = 'bottom'} = this.props;\n    const {dimensions} = this.state;\n\n    const DropDownWrapperComponent = this.props\n      .DropDownWrapperComponent as React.ComponentType<any>;\n\n    return (\n      <Portaled left={0} top={0} isOpened={this.state.showTypeahead} onClose={this._hideTypeahead}>\n        <DropDownWrapperComponent placement={placement} width={dimensions?.width}>\n          <Typeahead\n            customClasses={{\n              results: 'list-selector',\n              input: 'typeahead__input',\n              listItem: 'list__item',\n              listAnchor: 'list__item__anchor'\n            }}\n            options={this.props.options}\n            filterOption={this.props.filterOption}\n            fixedOptions={this.props.fixedOptions}\n            placeholder={\n              this.props.typeaheadPlaceholder || intl\n                ? intl.formatMessage({id: 'placeholder.search'})\n                : 'Search'\n            }\n            onOptionSelected={this._selectItem}\n            customListComponent={this.props.DropDownRenderComponent}\n            customListHeaderComponent={this.props.DropdownHeaderComponent}\n            customListItemComponent={this.props.DropDownLineItemRenderComponent}\n            displayOption={Accessor.generateOptionToStringFor(this.props.displayOption)}\n            searchable={this.props.searchable}\n            searchOptions={this.props.searchOptions}\n            showOptionsWhenEmpty\n            selectedItems={toArray(this.props.selectedItems)}\n            light={this.props.inputTheme === 'light'}\n          />\n        </DropDownWrapperComponent>\n      </Portaled>\n    );\n  }\n\n  render() {\n    const selected = toArray(this.props.selectedItems);\n    const displayOption = Accessor.generateOptionToStringFor(this.props.displayOption);\n    const {disabled, inputTheme = 'primary'} = this.props;\n\n    const dropdownSelectProps = {\n      className: classnames({\n        active: this.state.showTypeahead\n      }),\n      displayOption,\n      disabled,\n      onClick: this._showTypeahead,\n      error: this.props.isError,\n      inputTheme,\n      size: this.props.size\n    };\n    const intl = this.props.intl;\n\n    return (\n      <div className={classnames('item-selector', this.props.className)} ref={this.root}>\n        <div style={{position: 'relative'}}>\n          {/* this part is used to display the label */}\n          {this.props.multiSelect ? (\n            <ChickletedInput\n              {...dropdownSelectProps}\n              selectedItems={toArray(this.props.selectedItems)}\n              placeholder={this.props.placeholder}\n              removeItem={this._removeItem}\n              reorderItems={this.props.reorderItems}\n              CustomChickletComponent={this.props.CustomChickletComponent}\n              inputTheme={inputTheme}\n            />\n          ) : (\n            <DropdownSelect\n              {...dropdownSelectProps}\n              value={selected[0]}\n              placeholder={this.props.placeholder}\n              erasable={this.props.erasable}\n              showArrow={this.props.showArrow}\n              onErase={this._onErase}\n              showDropdown={this._showTypeahead}\n              DropDownLineItemRenderComponent={this.props.DropDownLineItemRenderComponent}\n            />\n          )}\n          {/* this part is used to built the list */}\n          {this._renderDropdown(intl)}\n        </div>\n      </div>\n    );\n  }\n}\n\nconst ItemSelector = React.memo(ItemSelectorUnmemoized);\nItemSelector.displayName = 'ItemSelector';\n\nexport default injectIntl(ItemSelector);\n"],"mappings":";;;;;;;;;;;;;;;;;AAGA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,WAAA,GAAAC,sBAAA,CAAAF,OAAA;AACA,IAAAG,OAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,iBAAA,GAAAF,sBAAA,CAAAF,OAAA;AAEA,IAAAK,SAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,gBAAA,GAAAJ,sBAAA,CAAAF,OAAA;AACA,IAAAO,UAAA,GAAAL,sBAAA,CAAAF,OAAA;AACA,IAAAQ,aAAA,GAAAT,uBAAA,CAAAC,OAAA;AACA,IAAAS,SAAA,GAAAP,sBAAA,CAAAF,OAAA;AACA,IAAAU,MAAA,GAAAV,OAAA;AACA,IAAAW,YAAA,GAAAX,OAAA;AACA,IAAAY,UAAA,GAAAZ,OAAA;AAEA,IAAAa,eAAA,GAAAX,sBAAA,CAAAF,OAAA;AAA+C,IAAAc,eAAA,EAjB/C;AACA;AAAA,SAAAC,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,yBAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAjB,wBAAAiB,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAI,UAAA,SAAAJ,CAAA,eAAAA,CAAA,gBAAAK,OAAA,CAAAL,CAAA,0BAAAA,CAAA,sBAAAA,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAG,GAAA,CAAAN,CAAA,UAAAG,CAAA,CAAAI,GAAA,CAAAP,CAAA,OAAAQ,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAd,CAAA,oBAAAc,CAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAhB,CAAA,EAAAc,CAAA,SAAAG,CAAA,GAAAP,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAb,CAAA,EAAAc,CAAA,UAAAG,CAAA,KAAAA,CAAA,CAAAV,GAAA,IAAAU,CAAA,CAAAC,GAAA,IAAAP,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAG,CAAA,IAAAT,CAAA,CAAAM,CAAA,IAAAd,CAAA,CAAAc,CAAA,YAAAN,CAAA,cAAAR,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAe,GAAA,CAAAlB,CAAA,EAAAQ,CAAA,GAAAA,CAAA;AAAA,SAAAW,WAAAhB,CAAA,EAAAiB,CAAA,EAAApB,CAAA,WAAAoB,CAAA,OAAAC,gBAAA,aAAAD,CAAA,OAAAE,2BAAA,aAAAnB,CAAA,EAAAoB,yBAAA,KAAAC,OAAA,CAAAC,SAAA,CAAAL,CAAA,EAAApB,CAAA,YAAAqB,gBAAA,aAAAlB,CAAA,EAAAuB,WAAA,IAAAN,CAAA,CAAAO,KAAA,CAAAxB,CAAA,EAAAH,CAAA;AAAA,SAAAuB,0BAAA,cAAApB,CAAA,IAAAyB,OAAA,CAAAC,SAAA,CAAAC,OAAA,CAAAd,IAAA,CAAAQ,OAAA,CAAAC,SAAA,CAAAG,OAAA,iCAAAzB,CAAA,aAAAoB,yBAAA,YAAAA,0BAAA,aAAApB,CAAA;AAuBA,IAAM4B,eAAe,GAAGC,4BAAM,CAACC,GAAG,CAAAnC,eAAA,KAAAA,eAAA,OAAAoC,uBAAA,qGAIrB,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACC,gBAAgB;AAAA,GACvC,UAAAF,KAAK;EAAA,OAAIA,KAAK,CAACG,KAAK;AAAA,EAC9B;AAAC,IAoCIC,sBAAsB,0BAAAC,UAAA;EAAA,SAAAD,uBAAA;IAAA,IAAAE,KAAA;IAAA,IAAAC,gBAAA,mBAAAH,sBAAA;IAAA,SAAAI,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAAC,IAAA,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;MAAAF,IAAA,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;IAAA;IAAAP,KAAA,GAAAtB,UAAA,OAAAoB,sBAAA,KAAAU,MAAA,CAAAH,IAAA;IAAA,IAAAI,gBAAA,aAAAT,KAAA,WAalB;MACNU,aAAa,EAAE,KAAK;MACpBC,UAAU,EAAE;QACVd,KAAK,EAAE;MACT;IACF,CAAC;IAAA,IAAAY,gBAAA,aAAAT,KAAA,uBAkBiC,IAAAY,gBAAS,EAAC,CAAC;IAAA,IAAAH,gBAAA,aAAAT,KAAA,wBAExB,YAAM;MACzBA,KAAA,CAAKa,cAAc,CAAC,CAAC;IACvB,CAAC;IAAA,IAAAJ,gBAAA,aAAAT,KAAA,mBAEe,UAAAW,UAAU,EAAI;MAC5BX,KAAA,CAAKc,QAAQ,CAAC;QAACH,UAAU,EAAVA;MAAU,CAAC,CAAC;IAC7B,CAAC;IAAA,IAAAF,gBAAA,aAAAT,KAAA,oBAEgB,YAAM;MACrBA,KAAA,CAAKc,QAAQ,CAAC;QAACJ,aAAa,EAAE;MAAK,CAAC,CAAC;MACrCV,KAAA,CAAKe,OAAO,CAAC,CAAC;IAChB,CAAC;IAAA,IAAAN,gBAAA,aAAAT,KAAA,aAES,YAAM;MACd;MACA;MACA,IAAIA,KAAA,CAAKN,KAAK,CAACsB,MAAM,EAAE;QACrBhB,KAAA,CAAKN,KAAK,CAACsB,MAAM,CAAC,CAAC;MACrB;IACF,CAAC;IAAA,IAAAP,gBAAA,aAAAT,KAAA,iBAEa,UAACiB,IAAI,EAAE1D,CAAC,EAAK;MACzB;MACAA,CAAC,CAAC2D,cAAc,CAAC,CAAC;MAClB3D,CAAC,CAAC4D,eAAe,CAAC,CAAC;MACnB,IAAMC,kBAAkB,GAAG,IAAAC,oBAAO,EAACrB,KAAA,CAAKN,KAAK,CAAC4B,aAAa,CAAC;MAC5D,IAAMC,KAAK,GAAGH,kBAAkB,CAACI,SAAS,CAAC,UAAA9D,CAAC;QAAA,OAAIA,CAAC,KAAKuD,IAAI;MAAA,EAAC;MAE3D,IAAIM,KAAK,GAAG,CAAC,EAAE;QACb;MACF;MAEA,IAAME,KAAK,MAAAjB,MAAA,KAAAkB,mBAAA,aACNN,kBAAkB,CAACO,KAAK,CAAC,CAAC,EAAEJ,KAAK,CAAC,OAAAG,mBAAA,aAClCN,kBAAkB,CAACO,KAAK,CAACJ,KAAK,GAAG,CAAC,EAAEH,kBAAkB,CAAChB,MAAM,CAAC,EAClE;MAEDJ,KAAA,CAAKN,KAAK,CAACkC,QAAQ,CAACH,KAAK,CAAC;MAE1B,IAAIzB,KAAA,CAAKN,KAAK,CAACmC,aAAa,EAAE;QAC5B7B,KAAA,CAAKc,QAAQ,CAAC;UAACJ,aAAa,EAAE;QAAK,CAAC,CAAC;QACrCV,KAAA,CAAKe,OAAO,CAAC,CAAC;MAChB;IACF,CAAC;IAAA,IAAAN,gBAAA,aAAAT,KAAA,iBAEa,UAAAiB,IAAI,EAAI;MACpB,IAAMa,QAAQ,GAAGC,oBAAQ,CAACC,yBAAyB,CACjDhC,KAAA,CAAKN,KAAK,CAACuC,cAAc,IAAIjC,KAAA,CAAKN,KAAK,CAACwC,aAC1C,CAAC;MAED,IAAMC,gBAAgB,GAAG,IAAAd,oBAAO,EAACrB,KAAA,CAAKN,KAAK,CAAC4B,aAAa,CAAC;MAE1D,IAAItB,KAAA,CAAKN,KAAK,CAAC0C,WAAW,EAAE;QAC1B,IAAMX,KAAK,GAAG,IAAAY,kBAAM,EAACF,gBAAgB,CAAC3B,MAAM,CAAC,IAAAa,oBAAO,EAACJ,IAAI,CAAC,CAAC,EAAEa,QAAQ,CAAC;QACtE9B,KAAA,CAAKN,KAAK,CAACkC,QAAQ,CAACH,KAAK,CAAC;MAC5B,CAAC,MAAM;QACLzB,KAAA,CAAKN,KAAK,CAACkC,QAAQ,CAACE,QAAQ,CAACb,IAAI,CAAC,CAAC;MACrC;MAEA,IAAIjB,KAAA,CAAKN,KAAK,CAACmC,aAAa,EAAE;QAC5B7B,KAAA,CAAKc,QAAQ,CAAC;UAACJ,aAAa,EAAE;QAAK,CAAC,CAAC;QACrCV,KAAA,CAAKe,OAAO,CAAC,CAAC;MAChB;IACF,CAAC;IAAA,IAAAN,gBAAA,aAAAT,KAAA,cAE6B,UAAAzC,CAAC,EAAI;MACjCA,CAAC,CAAC4D,eAAe,CAAC,CAAC;MACnBnB,KAAA,CAAKN,KAAK,CAACkC,QAAQ,CAAC,IAAI,CAAC;IAC3B,CAAC;IAAA,IAAAnB,gBAAA,aAAAT,KAAA,oBAEmC,UAAAzC,CAAC,EAAI;MACvCA,CAAC,CAAC4D,eAAe,CAAC,CAAC;MACnB,IAAI,CAACnB,KAAA,CAAKN,KAAK,CAAC4C,QAAQ,EAAE;QACxB,IAAItC,KAAA,CAAKN,KAAK,CAAC6C,MAAM,EAAE;UACrBvC,KAAA,CAAKN,KAAK,CAAC6C,MAAM,CAAC,CAAC;QACrB;QACAvC,KAAA,CAAKc,QAAQ,CAAC;UACZJ,aAAa,EAAE;QACjB,CAAC,CAAC;MACJ;IACF,CAAC;IAAA,OAAAV,KAAA;EAAA;EAAA,IAAAwC,UAAA,aAAA1C,sBAAA,EAAAC,UAAA;EAAA,WAAA0C,aAAA,aAAA3C,sBAAA;IAAA4C,GAAA;IAAAC,KAAA,EAlGD,SAAAC,iBAAiBA,CAAA,EAAG;MAClB,IAAI,IAAI,CAAClD,KAAK,CAACmD,mBAAmB,EAAE;QAClC,IAAI,CAAC/B,QAAQ,CAAC;UAACJ,aAAa,EAAE;QAAI,CAAC,CAAC;MACtC;MAEA,IAAI,IAAI,CAACoC,IAAI,CAACC,OAAO,YAAYC,WAAW,EAAE;QAC5C,IAAAC,wBAAiB,EAAC,IAAI,CAACH,IAAI,CAACC,OAAO,EAAE,IAAI,CAACG,aAAa,CAAC;MAC1D;IACF;EAAC;IAAAR,GAAA;IAAAC,KAAA,EAED,SAAAQ,oBAAoBA,CAAA,EAAG;MACrB,IAAI,IAAI,CAACL,IAAI,CAACC,OAAO,YAAYC,WAAW,EAAE;QAC5C,IAAAI,0BAAmB,EAAC,IAAI,CAACN,IAAI,CAACC,OAAO,CAAC;MACxC;IACF;EAAC;IAAAL,GAAA;IAAAC,KAAA,EAsFD,SAAAU,eAAeA,CAACC,IAAe,EAAE;MAC/B,IAAAC,qBAAA,GAA+B,IAAI,CAAC7D,KAAK,CAAlC8D,SAAS;QAATA,SAAS,GAAAD,qBAAA,cAAG,QAAQ,GAAAA,qBAAA;MAC3B,IAAO5C,UAAU,GAAI,IAAI,CAAC8C,KAAK,CAAxB9C,UAAU;MAEjB,IAAM+C,wBAAwB,GAAG,IAAI,CAAChE,KAAK,CACxCgE,wBAAoD;MAEvD,oBACErH,MAAA,YAAAsH,aAAA,CAAC3G,SAAA,WAAQ;QAAC4G,IAAI,EAAE,CAAE;QAACC,GAAG,EAAE,CAAE;QAACC,QAAQ,EAAE,IAAI,CAACL,KAAK,CAAC/C,aAAc;QAACqD,OAAO,EAAE,IAAI,CAAClD;MAAe,gBAC1FxE,MAAA,YAAAsH,aAAA,CAACD,wBAAwB;QAACF,SAAS,EAAEA,SAAU;QAAC3D,KAAK,EAAEc,UAAU,aAAVA,UAAU,uBAAVA,UAAU,CAAEd;MAAM,gBACvExD,MAAA,YAAAsH,aAAA,CAAC7G,UAAA,WAAS;QACRkH,aAAa,EAAE;UACbC,OAAO,EAAE,eAAe;UACxBC,KAAK,EAAE,kBAAkB;UACzBC,QAAQ,EAAE,YAAY;UACtBC,UAAU,EAAE;QACd,CAAE;QACFC,OAAO,EAAE,IAAI,CAAC3E,KAAK,CAAC2E,OAAQ;QAC5BC,YAAY,EAAE,IAAI,CAAC5E,KAAK,CAAC4E,YAAa;QACtCC,YAAY,EAAE,IAAI,CAAC7E,KAAK,CAAC6E,YAAa;QACtCC,WAAW,EACT,IAAI,CAAC9E,KAAK,CAAC+E,oBAAoB,IAAInB,IAAI,GACnCA,IAAI,CAACoB,aAAa,CAAC;UAACC,EAAE,EAAE;QAAoB,CAAC,CAAC,GAC9C,QACL;QACDC,gBAAgB,EAAE,IAAI,CAACC,WAAY;QACnCC,mBAAmB,EAAE,IAAI,CAACpF,KAAK,CAACqF,uBAAwB;QACxDC,yBAAyB,EAAE,IAAI,CAACtF,KAAK,CAACuF,uBAAwB;QAC9DC,uBAAuB,EAAE,IAAI,CAACxF,KAAK,CAACyF,+BAAgC;QACpEjD,aAAa,EAAEH,oBAAQ,CAACC,yBAAyB,CAAC,IAAI,CAACtC,KAAK,CAACwC,aAAa,CAAE;QAC5EkD,UAAU,EAAE,IAAI,CAAC1F,KAAK,CAAC0F,UAAW;QAClCC,aAAa,EAAE,IAAI,CAAC3F,KAAK,CAAC2F,aAAc;QACxCC,oBAAoB;QACpBhE,aAAa,EAAE,IAAAD,oBAAO,EAAC,IAAI,CAAC3B,KAAK,CAAC4B,aAAa,CAAE;QACjDiE,KAAK,EAAE,IAAI,CAAC7F,KAAK,CAAC8F,UAAU,KAAK;MAAQ,CAC1C,CACuB,CAClB,CAAC;IAEf;EAAC;IAAA9C,GAAA;IAAAC,KAAA,EAED,SAAA8C,MAAMA,CAAA,EAAG;MACP,IAAMC,QAAQ,GAAG,IAAArE,oBAAO,EAAC,IAAI,CAAC3B,KAAK,CAAC4B,aAAa,CAAC;MAClD,IAAMY,aAAa,GAAGH,oBAAQ,CAACC,yBAAyB,CAAC,IAAI,CAACtC,KAAK,CAACwC,aAAa,CAAC;MAClF,IAAAyD,WAAA,GAA2C,IAAI,CAACjG,KAAK;QAA9C4C,QAAQ,GAAAqD,WAAA,CAARrD,QAAQ;QAAAsD,qBAAA,GAAAD,WAAA,CAAEH,UAAU;QAAVA,UAAU,GAAAI,qBAAA,cAAG,SAAS,GAAAA,qBAAA;MAEvC,IAAMC,mBAAmB,GAAG;QAC1BC,SAAS,EAAE,IAAAC,sBAAU,EAAC;UACpBC,MAAM,EAAE,IAAI,CAACvC,KAAK,CAAC/C;QACrB,CAAC,CAAC;QACFwB,aAAa,EAAbA,aAAa;QACbI,QAAQ,EAARA,QAAQ;QACR2D,OAAO,EAAE,IAAI,CAACC,cAAc;QAC5BC,KAAK,EAAE,IAAI,CAACzG,KAAK,CAAC0G,OAAO;QACzBZ,UAAU,EAAVA,UAAU;QACVa,IAAI,EAAE,IAAI,CAAC3G,KAAK,CAAC2G;MACnB,CAAC;MACD,IAAM/C,IAAI,GAAG,IAAI,CAAC5D,KAAK,CAAC4D,IAAI;MAE5B,oBACEjH,MAAA,YAAAsH,aAAA;QAAKmC,SAAS,EAAE,IAAAC,sBAAU,EAAC,eAAe,EAAE,IAAI,CAACrG,KAAK,CAACoG,SAAS,CAAE;QAACQ,GAAG,EAAE,IAAI,CAACxD;MAAK,gBAChFzG,MAAA,YAAAsH,aAAA;QAAK4C,KAAK,EAAE;UAACC,QAAQ,EAAE;QAAU;MAAE,GAEhC,IAAI,CAAC9G,KAAK,CAAC0C,WAAW,gBACrB/F,MAAA,YAAAsH,aAAA,CAAC9G,gBAAA,WAAe,MAAA4J,SAAA,iBACVZ,mBAAmB;QACvBvE,aAAa,EAAE,IAAAD,oBAAO,EAAC,IAAI,CAAC3B,KAAK,CAAC4B,aAAa,CAAE;QACjDkD,WAAW,EAAE,IAAI,CAAC9E,KAAK,CAAC8E,WAAY;QACpCkC,UAAU,EAAE,IAAI,CAACC,WAAY;QAC7BC,YAAY,EAAE,IAAI,CAAClH,KAAK,CAACkH,YAAa;QACtCC,uBAAuB,EAAE,IAAI,CAACnH,KAAK,CAACmH,uBAAwB;QAC5DrB,UAAU,EAAEA;MAAW,EACxB,CAAC,gBAEFnJ,MAAA,YAAAsH,aAAA,CAACvG,eAAA,WAAc,MAAAqJ,SAAA,iBACTZ,mBAAmB;QACvBlD,KAAK,EAAE+C,QAAQ,CAAC,CAAC,CAAE;QACnBlB,WAAW,EAAE,IAAI,CAAC9E,KAAK,CAAC8E,WAAY;QACpCsC,QAAQ,EAAE,IAAI,CAACpH,KAAK,CAACoH,QAAS;QAC9BC,SAAS,EAAE,IAAI,CAACrH,KAAK,CAACqH,SAAU;QAChCC,OAAO,EAAE,IAAI,CAACC,QAAS;QACvBC,YAAY,EAAE,IAAI,CAAChB,cAAe;QAClCf,+BAA+B,EAAE,IAAI,CAACzF,KAAK,CAACyF;MAAgC,EAC7E,CACF,EAEA,IAAI,CAAC9B,eAAe,CAACC,IAAI,CACvB,CACF,CAAC;IAEV;EAAC;AAAA,EAlNkC6D,gBAAS;AAAA,IAAA1G,gBAAA,aAAxCX,sBAAsB,kBACJ;EACpBsC,WAAW,EAAE,IAAI;EACjBoC,WAAW,EAAE,wBAAwB;EACrC3C,aAAa,EAAE,IAAI;EACnBuD,UAAU,EAAE,IAAI;EAChBL,uBAAuB,EAAEqC,wBAAY;EACrCjC,+BAA+B,EAAEkC,sBAAQ;EACzC3D,wBAAwB,EAAEpE,eAAe;EACzCsH,YAAY,EAAEU,SAAS;EACvBxB,SAAS,EAAE;AACb,CAAC;AA0MH,IAAMyB,YAAY,gBAAGC,iBAAK,CAACC,IAAI,CAAC3H,sBAAsB,CAAC;AACvDyH,YAAY,CAACG,WAAW,GAAG,cAAc;AAAC,IAAAC,QAAA,GAAAC,OAAA,cAE3B,IAAAC,qBAAU,EAACN,YAAY,CAAC","ignoreList":[]}

package/dist/common/item-selector/typeahead.d.ts

@@ -0,0 +1,126 @@
+import React, { Component, ElementType, KeyboardEventHandler } from 'react';
+import DropdownList from './dropdown-list';
+import { Search } from '../icons';
+declare type Option = string | number | boolean | object | undefined;
+interface TypeaheadProps {
+    name?: string;
+    customClasses?: any;
+    resultsTruncatedMessage?: string;
+    options?: ReadonlyArray<Option>;
+    fixedOptions?: ReadonlyArray<Option> | null;
+    allowCustomValues?: number;
+    initialValue?: string;
+    value?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    textarea?: boolean;
+    inputProps?: object;
+    onOptionSelected?: (option: any, event: any) => any;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    onKeyPress?: KeyboardEventHandler<HTMLDivElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLDivElement>;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    filterOption?: string | ((o: Option, s: string) => boolean);
+    searchOptions?: (o: Option, s: string) => boolean;
+    displayOption?: string | ((o: Option) => string);
+    inputDisplayOption?: string | ((o: Option) => string);
+    formInputOption?: string | ((o: Option) => string);
+    defaultClassNames?: boolean;
+    customListComponent?: ElementType;
+    customListItemComponent?: ElementType;
+    customListHeaderComponent?: ElementType | null;
+    showOptionsWhenEmpty?: boolean;
+    searchable?: boolean;
+    light?: boolean;
+    inputIcon: ElementType;
+    className?: string;
+    selectedItems?: any[] | null;
+    autoFocus: boolean;
+    maxVisible?: number;
+}
+interface TypeaheadState {
+    searchResults: ReadonlyArray<string | number | boolean | object | undefined>;
+    entryValue?: string;
+    selection?: string;
+    selectionIndex: null;
+    isFocused: boolean;
+}
+declare function noop(): void;
+declare class Typeahead extends Component<TypeaheadProps, TypeaheadState> {
+    static defaultProps: {
+        options: never[];
+        customClasses: {
+            results: string;
+            input: string;
+            listItem: string;
+            listAnchor: string;
+        };
+        allowCustomValues: number;
+        initialValue: string;
+        value: string;
+        placeholder: string;
+        disabled: boolean;
+        textarea: boolean;
+        inputProps: {};
+        onOptionSelected: typeof noop;
+        onChange: typeof noop;
+        onKeyDown: typeof noop;
+        onKeyPress: typeof noop;
+        onKeyUp: typeof noop;
+        onFocus: typeof noop;
+        onBlur: typeof noop;
+        filterOption: null;
+        searchOptions: null;
+        inputDisplayOption: null;
+        defaultClassNames: boolean;
+        customListComponent: typeof DropdownList;
+        customListItemComponent: ({ value, displayOption, disabled, light }: {
+            value: any;
+            displayOption?: ((d: any) => any) | undefined;
+            disabled: any;
+            light: any;
+        }) => React.JSX.Element;
+        inputIcon: typeof Search;
+        customListHeaderComponent: null;
+        showOptionsWhenEmpty: boolean;
+        searchable: boolean;
+        resultsTruncatedMessage: null;
+        autoFocus: boolean;
+    };
+    static getDerivedStateFromProps(props: any, state: any): {
+        searchResults?: undefined;
+        prevOptions?: undefined;
+    } | {
+        searchResults: any;
+        prevOptions: any;
+    };
+    constructor(props: any);
+    componentDidMount(): void;
+    root: React.RefObject<HTMLDivElement>;
+    entry: React.RefObject<HTMLInputElement>;
+    focus: () => void;
+    _hasCustomValue: () => boolean;
+    _getCustomValue: () => string | null | undefined;
+    _renderIncrementalSearchResults(): React.JSX.Element;
+    getSelection(): Option | null;
+    _onOptionSelected: (option: any, event: any) => void;
+    _onTextEntryUpdated: () => void;
+    _onEnter: (event: any) => void;
+    _onEscape: () => void;
+    _onTab: (event: any) => void;
+    eventMap: () => {};
+    _nav: (delta: any) => void;
+    navDown: () => void;
+    navUp: () => void;
+    _onChange: React.ChangeEventHandler<HTMLInputElement>;
+    _onKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
+    _onFocus: React.FocusEventHandler<HTMLDivElement>;
+    _onBlur: React.FocusEventHandler<HTMLInputElement>;
+    _renderHiddenInput(): React.JSX.Element | null;
+    _hasHint(): boolean;
+    _hasFixedOptions(): number | false;
+    render(): React.JSX.Element;
+}
+export default Typeahead;