@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/esm/common/item-selector/dropdown-list.js

@@ -0,0 +1,251 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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;
+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 } from 'react';
+import classNames from 'classnames';
+import styled from 'styled-components';
+import { INIT_FILTER_ITEMS_IN_DROPDOWN } from '@kepler.gl/constants';
+var LEFT_BUTTON = 0;
+export var classList = {
+  list: 'list-selector',
+  listHeader: 'list__header',
+  listSection: 'list__section',
+  listItem: 'list__item',
+  listItemAnchor: 'list__item__anchor',
+  listItemFixed: 'list__item__fixed'
+};
+var defaultDisplay = function defaultDisplay(d) {
+  return d;
+};
+export var ListItem = function ListItem(_ref) {
+  var value = _ref.value,
+    _ref$displayOption = _ref.displayOption,
+    displayOption = _ref$displayOption === void 0 ? defaultDisplay : _ref$displayOption,
+    disabled = _ref.disabled;
+  var displayValue = displayOption(value);
+  return /*#__PURE__*/React.createElement("span", {
+    title: displayValue,
+    className: classNames(classList.listItemAnchor, {
+      disabled: disabled
+    })
+  }, displayValue);
+};
+var DropdownListWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  background-color: ", ";\n  border-top: 1px solid\n    ", ";\n  ", ";\n"])), function (props) {
+  return props.$light ? props.theme.dropdownListBgdLT : props.theme.dropdownListBgd;
+}, function (props) {
+  return props.$light ? props.theme.dropdownListBorderTopLT : props.theme.dropdownListBorderTop;
+}, function (props) {
+  return props.$light ? props.theme.dropdownListLT : props.theme.dropdownList;
+});
+var DropdownFooterWrapper = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  height: '0px';\n"])));
+
+// TODO: make Option a generic type
+var DropdownList = /*#__PURE__*/function (_Component) {
+  function DropdownList(props) {
+    var _this;
+    _classCallCheck(this, DropdownList);
+    _this = _callSuper(this, DropdownList, [props]);
+    _defineProperty(_this, "initNumberOfOptions", void 0);
+    _defineProperty(_this, "page", void 0);
+    _defineProperty(_this, "prevY", void 0);
+    _defineProperty(_this, "loadingRef", void 0);
+    _defineProperty(_this, "observer", void 0);
+    _defineProperty(_this, "handleObserver", function (entities) {
+      var y = entities[0].boundingClientRect.y;
+      if (_this.prevY > y) {
+        var options = _this._getOptions(_this.page);
+        if (options) _this.setState({
+          options: options
+        });
+      }
+      _this.prevY = y;
+    });
+    _this.state = {
+      options: []
+    };
+    _this.initNumberOfOptions = INIT_FILTER_ITEMS_IN_DROPDOWN;
+    _this.page = 0;
+    _this.prevY = 0;
+    _this.loadingRef = /*#__PURE__*/React.createRef();
+    return _this;
+  }
+  _inherits(DropdownList, _Component);
+  return _createClass(DropdownList, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var options = this._getOptions(this.page);
+      this.setState({
+        options: options
+      });
+      var divOptions = {
+        root: null,
+        rootMargin: '0%',
+        threshold: 1.0
+      };
+      if (this.loadingRef.current) {
+        this.observer = new IntersectionObserver(this.handleObserver, divOptions);
+        this.observer.observe(this.loadingRef.current);
+      }
+    }
+  }, {
+    key: "getSnapshotBeforeUpdate",
+    value: function getSnapshotBeforeUpdate(prevProps) {
+      if (prevProps.options !== this.props.options) {
+        // check if user searching, reset state.options at the first time
+        var options = this._getOptions(0);
+        this.setState({
+          options: options
+        });
+      }
+      return null;
+    }
+
+    // prevent console warning: getSnapshotBeforeUpdate() should be used with componentDidUpdate().
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      return;
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.loadingRef.current) {
+        var _this$observer, _this$loadingRef;
+        (_this$observer = this.observer) === null || _this$observer === void 0 || _this$observer.unobserve((_this$loadingRef = this.loadingRef) === null || _this$loadingRef === void 0 ? void 0 : _this$loadingRef.current);
+        this.page = 0;
+        this.prevY = 0;
+      }
+    }
+  }, {
+    key: "_getOptions",
+    value: function _getOptions(page) {
+      if (!this.props.options) {
+        return [];
+      }
+      var n = this.props.options.length;
+      if (n === 0) {
+        return [];
+      }
+      var start = page * this.initNumberOfOptions;
+      var end = start + this.initNumberOfOptions > n ? n : start + this.initNumberOfOptions;
+      if (start < end && end <= n) {
+        this.page = page + 1;
+        // in case of user searching, props.options will be updated
+        // so "page" value will be set to 0 and previous state.options will be discarded
+        return [].concat(_toConsumableArray(page > 0 ? this.state.options || [] : []), _toConsumableArray(this.props.options.slice(start, end)));
+      }
+      return null;
+    }
+  }, {
+    key: "_onClick",
+    value: function _onClick(result, event) {
+      event.preventDefault();
+      // only work when left is clicked
+      if (event.type === 'mousedown' && event.button === LEFT_BUTTON || event.type === 'click') {
+        var _this$props$onOptionS, _this$props;
+        (_this$props$onOptionS = (_this$props = this.props).onOptionSelected) === null || _this$props$onOptionS === void 0 || _this$props$onOptionS.call(_this$props, result, event);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props$options,
+        _this$props$customCla,
+        _this$props$customCla2,
+        _this2 = this,
+        _this$state$options;
+      var _this$props2 = this.props,
+        fixedOptions = _this$props2.fixedOptions,
+        light = _this$props2.light,
+        _this$props2$allowCus = _this$props2.allowCustomValues,
+        allowCustomValues = _this$props2$allowCus === void 0 ? 0 : _this$props2$allowCus,
+        _this$props2$customLi = _this$props2.customListItemComponent,
+        CustomListItemComponent = _this$props2$customLi === void 0 ? ListItem : _this$props2$customLi;
+      var _this$props$displayOp = this.props.displayOption,
+        display = _this$props$displayOp === void 0 ? defaultDisplay : _this$props$displayOp;
+
+      // Don't render if there are no options to display
+      if (!((_this$props$options = this.props.options) !== null && _this$props$options !== void 0 && _this$props$options.length) && allowCustomValues <= 0) {
+        return /*#__PURE__*/React.createElement("div", null);
+      }
+      var valueOffset = Array.isArray(fixedOptions) ? fixedOptions.length : 0;
+
+      // For some reason onClick is not fired when clicked on an option
+      // onMouseDown is used here as a workaround of #205 and other
+      return /*#__PURE__*/React.createElement(DropdownListWrapper, {
+        className: classNames(classList.list, (_this$props$customCla = this.props.customClasses) === null || _this$props$customCla === void 0 ? void 0 : _this$props$customCla.results),
+        $light: light
+      }, this.props.customListHeaderComponent ? /*#__PURE__*/React.createElement("div", {
+        className: classNames(classList.listHeader, (_this$props$customCla2 = this.props.customClasses) === null || _this$props$customCla2 === void 0 ? void 0 : _this$props$customCla2.listHeader)
+      }, /*#__PURE__*/React.createElement(this.props.customListHeaderComponent, null)) : null, valueOffset > 0 ? /*#__PURE__*/React.createElement("div", {
+        className: classList.listSection
+      }, fixedOptions === null || fixedOptions === void 0 ? void 0 : fixedOptions.map(function (value, i) {
+        var _this2$props$customCl;
+        return /*#__PURE__*/React.createElement("div", {
+          className: classNames(classList.listItem, _defineProperty({
+            hover: _this2.props.selectionIndex === i
+          }, classList.listItemFixed, true), (_this2$props$customCl = _this2.props.customClasses) === null || _this2$props$customCl === void 0 ? void 0 : _this2$props$customCl.listItem),
+          key: "".concat(display(value), "_").concat(i),
+          onMouseDown: function onMouseDown(e) {
+            return _this2._onClick(value, e);
+          },
+          onClick: function onClick(e) {
+            return _this2._onClick(value, e);
+          }
+        }, /*#__PURE__*/React.createElement(CustomListItemComponent, {
+          value: value,
+          displayOption: display,
+          light: light
+        }));
+      })) : null, (_this$state$options = this.state.options) === null || _this$state$options === void 0 ? void 0 : _this$state$options.map(function (value, i) {
+        var _this2$props$customCl2;
+        return /*#__PURE__*/React.createElement("div", {
+          className: classNames(classList.listItem, {
+            hover: _this2.props.selectionIndex === i + valueOffset,
+            selected: (_this2.props.selectedItems || []).find(function (item) {
+              return display(item) === display(value);
+            })
+          }, (_this2$props$customCl2 = _this2.props.customClasses) === null || _this2$props$customCl2 === void 0 ? void 0 : _this2$props$customCl2.listItem),
+          key: "".concat(display(value), "_").concat(i),
+          onMouseDown: function onMouseDown(e) {
+            return _this2._onClick(value, e);
+          },
+          onClick: function onClick(e) {
+            return _this2._onClick(value, e);
+          }
+        }, /*#__PURE__*/React.createElement(CustomListItemComponent, {
+          value: value,
+          displayOption: display
+        }));
+      }), /*#__PURE__*/React.createElement(DropdownFooterWrapper, {
+        ref: this.loadingRef
+      }));
+    }
+  }]);
+}(Component);
+_defineProperty(DropdownList, "defaultProps", {
+  customClasses: {},
+  customListItemComponent: ListItem,
+  customListHeaderComponent: null,
+  allowCustomValues: 0,
+  customValues: [],
+  displayOption: defaultDisplay,
+  onOptionSelected: function onOptionSelected() {
+    return;
+  },
+  defaultClassNames: true,
+  selectionIndex: null
+});
+export { DropdownList as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","classNames","styled","INIT_FILTER_ITEMS_IN_DROPDOWN","LEFT_BUTTON","classList","list","listHeader","listSection","listItem","listItemAnchor","listItemFixed","defaultDisplay","d","ListItem","_ref","value","_ref$displayOption","displayOption","disabled","displayValue","createElement","title","className","DropdownListWrapper","div","_templateObject","_taggedTemplateLiteral","props","$light","theme","dropdownListBgdLT","dropdownListBgd","dropdownListBorderTopLT","dropdownListBorderTop","dropdownListLT","dropdownList","DropdownFooterWrapper","_templateObject2","DropdownList","_Component","_this","_classCallCheck","_callSuper","_defineProperty","entities","y","boundingClientRect","prevY","options","_getOptions","page","setState","state","initNumberOfOptions","loadingRef","createRef","_inherits","_createClass","key","componentDidMount","divOptions","root","rootMargin","threshold","current","observer","IntersectionObserver","handleObserver","observe","getSnapshotBeforeUpdate","prevProps","componentDidUpdate","componentWillUnmount","_this$observer","_this$loadingRef","unobserve","n","length","start","end","concat","_toConsumableArray","slice","_onClick","result","event","preventDefault","type","button","_this$props$onOptionS","_this$props","onOptionSelected","call","render","_this$props$options","_this$props$customCla","_this$props$customCla2","_this2","_this$state$options","_this$props2","fixedOptions","light","_this$props2$allowCus","allowCustomValues","_this$props2$customLi","customListItemComponent","CustomListItemComponent","_this$props$displayOp","display","valueOffset","Array","isArray","customClasses","results","customListHeaderComponent","map","i","_this2$props$customCl","hover","selectionIndex","onMouseDown","e","onClick","_this2$props$customCl2","selected","selectedItems","find","item","ref","customValues","defaultClassNames","default"],"sources":["../../../../src/common/item-selector/dropdown-list.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, ElementType} from 'react';\nimport classNames from 'classnames';\nimport styled, {IStyledComponent} from 'styled-components';\nimport {INIT_FILTER_ITEMS_IN_DROPDOWN} from '@kepler.gl/constants';\nimport {BaseComponentProps} from '../../types';\n\nconst LEFT_BUTTON = 0;\n\nexport const classList = {\n  list: 'list-selector',\n  listHeader: 'list__header',\n  listSection: 'list__section',\n  listItem: 'list__item',\n  listItemAnchor: 'list__item__anchor',\n  listItemFixed: 'list__item__fixed'\n};\n\nexport type ListItemProps<Option> = {\n  value: Option;\n  displayOption: (opt: Option) => string;\n  disabled?: boolean;\n  light?: boolean;\n};\n\nconst defaultDisplay = d => d;\nexport const ListItem = ({value, displayOption = defaultDisplay, disabled}: ListItemProps<any>) => {\n  const displayValue = displayOption(value);\n  return (\n    <span title={displayValue} className={classNames(classList.listItemAnchor, {disabled})}>\n      {displayValue}\n    </span>\n  );\n};\n\nexport type DropdownListWrapperProps = BaseComponentProps & {\n  $light?: boolean;\n};\n\nconst DropdownListWrapper: IStyledComponent<\n  'web',\n  DropdownListWrapperProps\n> = styled.div<DropdownListWrapperProps>`\n  background-color: ${props =>\n    props.$light ? props.theme.dropdownListBgdLT : props.theme.dropdownListBgd};\n  border-top: 1px solid\n    ${props =>\n      props.$light ? props.theme.dropdownListBorderTopLT : props.theme.dropdownListBorderTop};\n  ${props => (props.$light ? props.theme.dropdownListLT : props.theme.dropdownList)};\n`;\n\nconst DropdownFooterWrapper = styled.div`\n  height: '0px';\n`;\n\ntype Option = string | number | boolean | object | any;\n// TODO: make Option a generic type\ninterface DropdownListProps {\n  options?: Option[];\n  allowCustomValues?: number;\n  customClasses?: {listHeader?: string; listItem?: string; results?: string};\n  customValues?: any[];\n  customListItemComponent?: ElementType;\n  customListHeaderComponent?: ElementType;\n  selectionIndex?: number;\n  onOptionSelected?: (option: Option, event: React.MouseEvent) => void;\n  displayOption?: (option: Option) => string;\n  defaultClassNames?: boolean;\n  areResultsTruncated?: boolean;\n  resultsTruncatedMessage?: string;\n  listItemComponent?: ElementType;\n  light?: boolean;\n  fixedOptions?: any[];\n  selectedItems?: any[]; // Passed through by Typeahead\n}\n\ninterface DropdownListState {\n  options: Array<any> | null;\n}\n\nexport default class DropdownList extends Component<DropdownListProps, DropdownListState> {\n  static defaultProps = {\n    customClasses: {},\n    customListItemComponent: ListItem,\n    customListHeaderComponent: null,\n    allowCustomValues: 0,\n    customValues: [],\n    displayOption: defaultDisplay,\n    onOptionSelected: () => {\n      return;\n    },\n    defaultClassNames: true,\n    selectionIndex: null\n  };\n\n  initNumberOfOptions: number;\n  page: number;\n  prevY: number;\n  loadingRef: React.RefObject<HTMLDivElement | null>;\n  observer: IntersectionObserver | undefined;\n\n  constructor(props) {\n    super(props);\n\n    this.state = {options: []};\n    this.initNumberOfOptions = INIT_FILTER_ITEMS_IN_DROPDOWN;\n    this.page = 0;\n    this.prevY = 0;\n    this.loadingRef = React.createRef<HTMLDivElement | null>();\n  }\n\n  componentDidMount() {\n    const options = this._getOptions(this.page);\n    this.setState({options});\n\n    const divOptions = {\n      root: null,\n      rootMargin: '0%',\n      threshold: 1.0\n    };\n\n    if (this.loadingRef.current) {\n      this.observer = new IntersectionObserver(this.handleObserver, divOptions);\n      this.observer.observe(this.loadingRef.current);\n    }\n  }\n\n  getSnapshotBeforeUpdate(prevProps: DropdownListProps) {\n    if (prevProps.options !== this.props.options) {\n      // check if user searching, reset state.options at the first time\n      const options = this._getOptions(0);\n      this.setState({options});\n    }\n    return null;\n  }\n\n  // prevent console warning: getSnapshotBeforeUpdate() should be used with componentDidUpdate().\n  componentDidUpdate() {\n    return;\n  }\n\n  componentWillUnmount() {\n    if (this.loadingRef.current) {\n      this.observer?.unobserve(this.loadingRef?.current);\n      this.page = 0;\n      this.prevY = 0;\n    }\n  }\n\n  handleObserver = entities => {\n    const y = entities[0].boundingClientRect.y;\n    if (this.prevY > y) {\n      const options = this._getOptions(this.page);\n      if (options) this.setState({options});\n    }\n    this.prevY = y;\n  };\n\n  _getOptions(page) {\n    if (!this.props.options) {\n      return [];\n    }\n\n    const n = this.props.options.length;\n    if (n === 0) {\n      return [];\n    }\n    const start = page * this.initNumberOfOptions;\n    const end = start + this.initNumberOfOptions > n ? n : start + this.initNumberOfOptions;\n\n    if (start < end && end <= n) {\n      this.page = page + 1;\n      // in case of user searching, props.options will be updated\n      // so \"page\" value will be set to 0 and previous state.options will be discarded\n      return [\n        ...(page > 0 ? this.state.options || [] : []),\n        ...this.props.options.slice(start, end)\n      ];\n    }\n\n    return null;\n  }\n\n  _onClick(result, event) {\n    event.preventDefault();\n    // only work when left is clicked\n    if ((event.type === 'mousedown' && event.button === LEFT_BUTTON) || event.type === 'click') {\n      this.props.onOptionSelected?.(result, event);\n    }\n  }\n\n  render() {\n    const {\n      fixedOptions,\n      light,\n      allowCustomValues = 0,\n      customListItemComponent: CustomListItemComponent = ListItem\n    } = this.props;\n    const {displayOption: display = defaultDisplay} = this.props;\n\n    // Don't render if there are no options to display\n    if (!this.props.options?.length && allowCustomValues <= 0) {\n      return <div />;\n    }\n\n    const valueOffset = Array.isArray(fixedOptions) ? fixedOptions.length : 0;\n\n    // For some reason onClick is not fired when clicked on an option\n    // onMouseDown is used here as a workaround of #205 and other\n    return (\n      <DropdownListWrapper\n        className={classNames(classList.list, this.props.customClasses?.results)}\n        $light={light}\n      >\n        {this.props.customListHeaderComponent ? (\n          <div className={classNames(classList.listHeader, this.props.customClasses?.listHeader)}>\n            <this.props.customListHeaderComponent />\n          </div>\n        ) : null}\n\n        {valueOffset > 0 ? (\n          <div className={classList.listSection}>\n            {fixedOptions?.map((value, i) => (\n              <div\n                className={classNames(\n                  classList.listItem,\n                  {\n                    hover: this.props.selectionIndex === i,\n                    [classList.listItemFixed]: true\n                  },\n                  this.props.customClasses?.listItem\n                )}\n                key={`${display(value)}_${i}`}\n                onMouseDown={e => this._onClick(value, e)}\n                onClick={e => this._onClick(value, e)}\n              >\n                <CustomListItemComponent value={value} displayOption={display} light={light} />\n              </div>\n            ))}\n          </div>\n        ) : null}\n\n        {this.state.options?.map((value, i) => (\n          <div\n            className={classNames(\n              classList.listItem,\n              {\n                hover: this.props.selectionIndex === i + valueOffset,\n                selected: (this.props.selectedItems || []).find(\n                  item => display(item) === display(value)\n                )\n              },\n              this.props.customClasses?.listItem\n            )}\n            key={`${display(value)}_${i}`}\n            onMouseDown={e => this._onClick(value, e)}\n            onClick={e => this._onClick(value, e)}\n          >\n            <CustomListItemComponent value={value} displayOption={display} />\n          </div>\n        ))}\n\n        <DropdownFooterWrapper ref={this.loadingRef} />\n      </DropdownListWrapper>\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,79 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { notNullorUndefined } from '@kepler.gl/common-utils';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { ArrowDown, Delete } from '../icons';
+import { ListItem } from './dropdown-list';
+import { shouldForwardProp } from '../styled-components';
+export var StyledDropdownSelect = styled.div.withConfig({
+  shouldForwardProp: shouldForwardProp
+}).attrs({
+  className: 'item-selector__dropdown'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\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;
+});
+export var DropdownSelectValue = styled.span.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\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 = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\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 ? ListItem : _ref$DropDownLineItem;
+  var hasValue = notNullorUndefined(value);
+  return /*#__PURE__*/React.createElement(StyledDropdownSelect, {
+    className: className,
+    onClick: onClick,
+    inputTheme: inputTheme,
+    size: size
+  }, /*#__PURE__*/React.createElement(DropdownSelectValue, {
+    hasPlaceholder: !hasValue,
+    inputTheme: inputTheme,
+    className: "item-selector__dropdown__value"
+  }, hasValue ? /*#__PURE__*/React.createElement(DropDownLineItemRenderComponent, {
+    displayOption: displayOption,
+    value: value,
+    disabled: Boolean(disabled),
+    light: inputTheme === 'light'
+  }) : /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: placeholder || 'placeholder.selectValue'
+  })), erasable && hasValue ? /*#__PURE__*/React.createElement(DropdownSelectActionRight, null, /*#__PURE__*/React.createElement(Delete, {
+    height: "16px",
+    onClick: onErase
+  })) : showArrow ? /*#__PURE__*/React.createElement(DropdownSelectActionRight, null, /*#__PURE__*/React.createElement(ArrowDown, {
+    height: "14px",
+    onClick: showDropdown
+  })) : null);
+}
+export default DropdownSelect;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","styled","notNullorUndefined","FormattedMessage","ArrowDown","Delete","ListItem","shouldForwardProp","StyledDropdownSelect","div","withConfig","attrs","className","_templateObject","_taggedTemplateLiteral","props","inputTheme","theme","secondaryInput","inputLT","input","size","inputBoxHeightSmall","inputBoxHeight","dropdownListAnchor","DropdownSelectValue","span","_templateObject2","hasPlaceholder","selectColorPlaceHolderLT","selectColorPlaceHolder","selectColorLT","selectColor","dropdownListItemLT","dropdownListItem","dropdownListAnchorLT","DropdownSelectActionRight","_templateObject3","subtextColor","textColor","DropdownSelect","_ref","displayOption","disabled","onClick","value","placeholder","erasable","showArrow","onErase","showDropdown","_ref$DropDownLineItem","DropDownLineItemRenderComponent","hasValue","createElement","Boolean","light","id","height"],"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';\nimport {shouldForwardProp} from '../styled-components';\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\n  .withConfig({shouldForwardProp})\n  .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.withConfig({shouldForwardProp})<{\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=\"16px\" 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":[]}