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

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

@@ -0,0 +1,247 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+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;
+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 classnames from 'classnames';
+import uniqBy from 'es-toolkit/compat/uniqBy';
+import styled from 'styled-components';
+import Accessor from './accessor';
+import ChickletedInput from './chickleted-input';
+import Typeahead from './typeahead';
+import DropdownList, { ListItem } from './dropdown-list';
+import Portaled from '../../common/portaled';
+import { observeDimensions, unobserveDimensions } from '@kepler.gl/utils';
+import { toArray } from '@kepler.gl/common-utils';
+import { injectIntl } from 'react-intl';
+import DropdownSelect from './dropdown-select';
+import { shouldForwardProp } from '../styled-components';
+var DropdownWrapper = styled.div.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\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;
+    _classCallCheck(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));
+    _defineProperty(_this, "state", {
+      showTypeahead: false,
+      dimensions: {
+        width: 200
+      }
+    });
+    _defineProperty(_this, "root", /*#__PURE__*/createRef());
+    _defineProperty(_this, "handleClickOutside", function () {
+      _this._hideTypeahead();
+    });
+    _defineProperty(_this, "_handleResize", function (dimensions) {
+      _this.setState({
+        dimensions: dimensions
+      });
+    });
+    _defineProperty(_this, "_hideTypeahead", function () {
+      _this.setState({
+        showTypeahead: false
+      });
+      _this._onBlur();
+    });
+    _defineProperty(_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();
+      }
+    });
+    _defineProperty(_this, "_removeItem", function (item, e) {
+      // only used when multiSelect = true
+      e.preventDefault();
+      e.stopPropagation();
+      var multiSelectedItems = toArray(_this.props.selectedItems);
+      var index = multiSelectedItems.findIndex(function (t) {
+        return t === item;
+      });
+      if (index < 0) {
+        return;
+      }
+      var items = [].concat(_toConsumableArray(multiSelectedItems.slice(0, index)), _toConsumableArray(multiSelectedItems.slice(index + 1, multiSelectedItems.length)));
+      _this.props.onChange(items);
+      if (_this.props.closeOnSelect) {
+        _this.setState({
+          showTypeahead: false
+        });
+        _this._onBlur();
+      }
+    });
+    _defineProperty(_this, "_selectItem", function (item) {
+      var getValue = Accessor.generateOptionToStringFor(_this.props.getOptionValue || _this.props.displayOption);
+      var previousSelected = toArray(_this.props.selectedItems);
+      if (_this.props.multiSelect) {
+        var items = uniqBy(previousSelected.concat(toArray(item)), getValue);
+        _this.props.onChange(items);
+      } else {
+        _this.props.onChange(getValue(item));
+      }
+      if (_this.props.closeOnSelect) {
+        _this.setState({
+          showTypeahead: false
+        });
+        _this._onBlur();
+      }
+    });
+    _defineProperty(_this, "_onErase", function (e) {
+      e.stopPropagation();
+      _this.props.onChange(null);
+    });
+    _defineProperty(_this, "_showTypeahead", function (e) {
+      e.stopPropagation();
+      if (!_this.props.disabled) {
+        if (_this.props.onOpen) {
+          _this.props.onOpen();
+        }
+        _this.setState({
+          showTypeahead: true
+        });
+      }
+    });
+    return _this;
+  }
+  _inherits(ItemSelectorUnmemoized, _Component);
+  return _createClass(ItemSelectorUnmemoized, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.showDropdownOnMount) {
+        this.setState({
+          showTypeahead: true
+        });
+      }
+      if (this.root.current instanceof HTMLElement) {
+        observeDimensions(this.root.current, this._handleResize);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.root.current instanceof HTMLElement) {
+        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.createElement(Portaled, {
+        left: 0,
+        top: 0,
+        isOpened: this.state.showTypeahead,
+        onClose: this._hideTypeahead
+      }, /*#__PURE__*/React.createElement(DropDownWrapperComponent, {
+        placement: placement,
+        width: dimensions === null || dimensions === void 0 ? void 0 : dimensions.width
+      }, /*#__PURE__*/React.createElement(Typeahead, {
+        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.generateOptionToStringFor(this.props.displayOption),
+        searchable: this.props.searchable,
+        searchOptions: this.props.searchOptions,
+        showOptionsWhenEmpty: true,
+        selectedItems: toArray(this.props.selectedItems),
+        light: this.props.inputTheme === 'light'
+      })));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var selected = toArray(this.props.selectedItems);
+      var displayOption = Accessor.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: classnames({
+          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.createElement("div", {
+        className: classnames('item-selector', this.props.className),
+        ref: this.root
+      }, /*#__PURE__*/React.createElement("div", {
+        style: {
+          position: 'relative'
+        }
+      }, this.props.multiSelect ? /*#__PURE__*/React.createElement(ChickletedInput, _extends({}, dropdownSelectProps, {
+        selectedItems: toArray(this.props.selectedItems),
+        placeholder: this.props.placeholder,
+        removeItem: this._removeItem,
+        reorderItems: this.props.reorderItems,
+        CustomChickletComponent: this.props.CustomChickletComponent,
+        inputTheme: inputTheme
+      })) : /*#__PURE__*/React.createElement(DropdownSelect, _extends({}, 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)));
+    }
+  }]);
+}(Component);
+_defineProperty(ItemSelectorUnmemoized, "defaultProps", {
+  multiSelect: true,
+  placeholder: 'placeholder.enterValue',
+  closeOnSelect: true,
+  searchable: true,
+  DropDownRenderComponent: DropdownList,
+  DropDownLineItemRenderComponent: ListItem,
+  DropDownWrapperComponent: DropdownWrapper,
+  reorderItems: undefined,
+  className: ''
+});
+var ItemSelector = /*#__PURE__*/React.memo(ItemSelectorUnmemoized);
+ItemSelector.displayName = 'ItemSelector';
+export default injectIntl(ItemSelector);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createRef","classnames","uniqBy","styled","Accessor","ChickletedInput","Typeahead","DropdownList","ListItem","Portaled","observeDimensions","unobserveDimensions","toArray","injectIntl","DropdownSelect","shouldForwardProp","DropdownWrapper","div","withConfig","_templateObject","_taggedTemplateLiteral","props","theme","dropdownWrapperZ","width","ItemSelectorUnmemoized","_Component","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","_defineProperty","showTypeahead","dimensions","_hideTypeahead","setState","_onBlur","onBlur","item","e","preventDefault","stopPropagation","multiSelectedItems","selectedItems","index","findIndex","t","items","_toConsumableArray","slice","onChange","closeOnSelect","getValue","generateOptionToStringFor","getOptionValue","displayOption","previousSelected","multiSelect","disabled","onOpen","_inherits","_createClass","key","value","componentDidMount","showDropdownOnMount","root","current","HTMLElement","_handleResize","componentWillUnmount","_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","active","onClick","_showTypeahead","error","isError","size","ref","style","position","_extends","removeItem","_removeItem","reorderItems","CustomChickletComponent","erasable","showArrow","onErase","_onErase","showDropdown","undefined","ItemSelector","memo","displayName"],"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 'es-toolkit/compat/uniqBy';\nimport styled, {IStyledComponent} 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';\nimport {shouldForwardProp} from '../styled-components';\n\nexport type DropdownWrapperProps = {\n  placement?: string;\n  width: number;\n};\n\nconst DropdownWrapper: IStyledComponent<'web', DropdownWrapperProps> = styled.div.withConfig({\n  shouldForwardProp\n})<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 | null> = 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":"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","ignoreList":[]}