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

package/dist/esm/common/data-table/option-dropdown.js

@@ -0,0 +1,152 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useState } from 'react';
+import styled from 'styled-components';
+import Portaled from '../portaled';
+import DropdownList from '../item-selector/dropdown-list';
+import { SORT_ORDER, TABLE_OPTION, TABLE_OPTION_LIST } from '@kepler.gl/constants';
+import { getFieldFormatLabels } from '@kepler.gl/utils';
+import { ArrowDown, ArrowUp, Clipboard, Pin, Cancel, Hash } from '../icons';
+var ListItem = function ListItem(_ref) {
+  var value = _ref.value;
+  return /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(value.icon, {
+    height: "13px"
+  }), value.display);
+};
+
+// make hash icon smaller
+var StyledOptionsDropdown = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  .list-selector {\n    border-top: 0;\n    width: max-content;\n    padding: 8px 0;\n  }\n\n  .list__item > div {\n    display: flex;\n    align-items: center;\n    flex-direction: row;\n    justify-content: flex-start;\n    line-height: 18px;\n\n    svg {\n      margin-right: 5px;\n    }\n\n    .data-ex-icons-hash {\n      width: 10px;\n      height: 10px;\n      stroke-width: 1px;\n      margin-left: 2px;\n      margin-right: 6px;\n    }\n  }\n"])));
+var StyledPopover = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  width: 184px;\n  height: 160px;\n  z-index: 101;\n  .list-selector {\n    max-height: 160px;\n  }\n  .hover:after {\n    content: '\\2713';\n    margin-left: 5px;\n  }\n"], ["\n  width: 184px;\n  height: 160px;\n  z-index: 101;\n  .list-selector {\n    max-height: 160px;\n  }\n  .hover:after {\n    content: '\\\\2713';\n    margin-left: 5px;\n  }\n"])));
+export var FormatterDropdown = function FormatterDropdown(props) {
+  var left = props.left,
+    top = props.top,
+    isOpened = props.isOpened,
+    _props$displayFormat = props.displayFormat,
+    displayFormat = _props$displayFormat === void 0 ? 'None' : _props$displayFormat,
+    setDisplayFormat = props.setDisplayFormat,
+    onClose = props.onClose,
+    formatLabels = props.formatLabels;
+  var selectionIndex = formatLabels.findIndex(function (label) {
+    return label.format === displayFormat;
+  });
+  var onSelectDisplayFormat = useCallback(function (result) {
+    setDisplayFormat === null || setDisplayFormat === void 0 || setDisplayFormat(result);
+    onClose();
+  }, [setDisplayFormat, onClose]);
+  return /*#__PURE__*/React.createElement(Portaled, {
+    left: left,
+    top: top,
+    isOpened: isOpened,
+    onClose: onClose
+  }, /*#__PURE__*/React.createElement(StyledPopover, {
+    className: "formatter-popover"
+  }, /*#__PURE__*/React.createElement(DropdownList, {
+    options: formatLabels,
+    selectionIndex: selectionIndex,
+    displayOption: function displayOption(option) {
+      return option.label;
+    },
+    onOptionSelected: onSelectDisplayFormat,
+    light: true
+  })));
+};
+var OptionDropdown = function OptionDropdown(props) {
+  var _colMeta$column;
+  var isOpened = props.isOpened,
+    column = props.column,
+    colMeta = props.colMeta,
+    toggleMoreOptions = props.toggleMoreOptions,
+    sortTableColumn = props.sortTableColumn,
+    pinTableColumn = props.pinTableColumn,
+    copyTableColumn = props.copyTableColumn,
+    setDisplayFormat = props.setDisplayFormat;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    showFormatter = _useState2[0],
+    setShowFormatter = _useState2[1];
+  var onOptionSelected = useCallback(function (_ref2) {
+    var value = _ref2.value;
+    switch (value) {
+      case TABLE_OPTION.SORT_ASC:
+        sortTableColumn === null || sortTableColumn === void 0 || sortTableColumn(SORT_ORDER.ASCENDING);
+        break;
+      case TABLE_OPTION.SORT_DES:
+        sortTableColumn === null || sortTableColumn === void 0 || sortTableColumn(SORT_ORDER.DESCENDING);
+        break;
+      case TABLE_OPTION.UNSORT:
+        sortTableColumn === null || sortTableColumn === void 0 || sortTableColumn(SORT_ORDER.UNSORT);
+        break;
+      case TABLE_OPTION.PIN:
+        pinTableColumn();
+        break;
+      case TABLE_OPTION.UNPIN:
+        pinTableColumn();
+        break;
+      case TABLE_OPTION.COPY:
+        copyTableColumn();
+        break;
+      case TABLE_OPTION.FORMAT_COLUMN:
+        setShowFormatter(true);
+        return;
+      default:
+        break;
+    }
+    toggleMoreOptions(column);
+  }, [column, sortTableColumn, pinTableColumn, copyTableColumn, toggleMoreOptions]);
+  var TABLE_OPTION_LIST_ICONS = {
+    Pin: Pin,
+    ArrowDown: ArrowDown,
+    ArrowUp: ArrowUp,
+    Clipboard: Clipboard,
+    Cancel: Cancel,
+    Hash: Hash
+  };
+  var formatLabels = getFieldFormatLabels(colMeta[column].type);
+  var options = TABLE_OPTION_LIST.filter(function (op) {
+    // cant use conditions because it creates a circular dependency
+    // TODO: move condition clause out of default-settings TABLE_OPTION_LIST
+    var validToFormat = op.value !== TABLE_OPTION.FORMAT_COLUMN || formatLabels.length;
+    return (!op.condition || op.condition(props)) && validToFormat;
+  }).map(function (op) {
+    return _objectSpread(_objectSpread({}, op), {}, {
+      icon: TABLE_OPTION_LIST_ICONS[op.icon]
+    });
+  });
+  var onClose = useCallback(function () {
+    setShowFormatter(false);
+    toggleMoreOptions(column);
+  }, [column, toggleMoreOptions]);
+  return /*#__PURE__*/React.createElement(Portaled, {
+    right: 120,
+    top: 20,
+    isOpened: isOpened,
+    onClose: onClose
+  }, /*#__PURE__*/React.createElement(StyledOptionsDropdown, {
+    className: "more-options"
+  }, /*#__PURE__*/React.createElement(DropdownList, {
+    displayOption: function displayOption(d) {
+      return d.display;
+    },
+    options: options,
+    customListItemComponent: ListItem,
+    onOptionSelected: onOptionSelected,
+    light: true
+  }), /*#__PURE__*/React.createElement(FormatterDropdown, {
+    left: 120,
+    top: -10,
+    isOpened: Boolean(isOpened && showFormatter),
+    formatLabels: formatLabels,
+    displayFormat: (_colMeta$column = colMeta[column]) === null || _colMeta$column === void 0 ? void 0 : _colMeta$column.displayFormat,
+    setDisplayFormat: setDisplayFormat,
+    onClose: onClose
+  })));
+};
+export default OptionDropdown;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","styled","Portaled","DropdownList","SORT_ORDER","TABLE_OPTION","TABLE_OPTION_LIST","getFieldFormatLabels","ArrowDown","ArrowUp","Clipboard","Pin","Cancel","Hash","ListItem","_ref","value","createElement","icon","height","display","StyledOptionsDropdown","div","_templateObject","_taggedTemplateLiteral","StyledPopover","_templateObject2","FormatterDropdown","props","left","top","isOpened","_props$displayFormat","displayFormat","setDisplayFormat","onClose","formatLabels","selectionIndex","findIndex","label","format","onSelectDisplayFormat","result","className","options","displayOption","option","onOptionSelected","light","OptionDropdown","_colMeta$column","column","colMeta","toggleMoreOptions","sortTableColumn","pinTableColumn","copyTableColumn","_useState","_useState2","_slicedToArray","showFormatter","setShowFormatter","_ref2","SORT_ASC","ASCENDING","SORT_DES","DESCENDING","UNSORT","PIN","UNPIN","COPY","FORMAT_COLUMN","TABLE_OPTION_LIST_ICONS","type","filter","op","validToFormat","length","condition","map","_objectSpread","right","d","customListItemComponent","Boolean"],"sources":["../../../../src/common/data-table/option-dropdown.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useState} from 'react';\nimport styled from 'styled-components';\nimport Portaled from '../portaled';\nimport DropdownList from '../item-selector/dropdown-list';\nimport {\n  SORT_ORDER,\n  TABLE_OPTION,\n  TABLE_OPTION_LIST,\n  TooltipFormat,\n  TableOption\n} from '@kepler.gl/constants';\nimport {getFieldFormatLabels} from '@kepler.gl/utils';\nimport {ColMeta} from '@kepler.gl/types';\nimport {ArrowDown, ArrowUp, Clipboard, Pin, Cancel, Hash} from '../icons';\n\nconst ListItem = ({value}) => (\n  <div>\n    <value.icon height=\"13px\" />\n    {value.display}\n  </div>\n);\n\n// make hash icon smaller\nconst StyledOptionsDropdown = styled.div`\n  .list-selector {\n    border-top: 0;\n    width: max-content;\n    padding: 8px 0;\n  }\n\n  .list__item > div {\n    display: flex;\n    align-items: center;\n    flex-direction: row;\n    justify-content: flex-start;\n    line-height: 18px;\n\n    svg {\n      margin-right: 5px;\n    }\n\n    .data-ex-icons-hash {\n      width: 10px;\n      height: 10px;\n      stroke-width: 1px;\n      margin-left: 2px;\n      margin-right: 6px;\n    }\n  }\n`;\n\nconst StyledPopover = styled.div`\n  width: 184px;\n  height: 160px;\n  z-index: 101;\n  .list-selector {\n    max-height: 160px;\n  }\n  .hover:after {\n    content: '\\\\2713';\n    margin-left: 5px;\n  }\n`;\n\nexport type FormatterDropdownProps = {\n  left: number;\n  top: number;\n  isOpened: boolean;\n  displayFormat?: string;\n  setDisplayFormat?: (displayFormat: TooltipFormat) => void;\n  onClose: () => void;\n  formatLabels: TooltipFormat[];\n};\n\nexport const FormatterDropdown: React.FC<FormatterDropdownProps> = (\n  props: FormatterDropdownProps\n) => {\n  const {\n    left,\n    top,\n    isOpened,\n    displayFormat = 'None',\n    setDisplayFormat,\n    onClose,\n    formatLabels\n  } = props;\n  const selectionIndex = formatLabels.findIndex(label => label.format === displayFormat);\n\n  const onSelectDisplayFormat = useCallback(\n    result => {\n      setDisplayFormat?.(result);\n      onClose();\n    },\n    [setDisplayFormat, onClose]\n  );\n\n  return (\n    <Portaled left={left} top={top} isOpened={isOpened} onClose={onClose}>\n      <StyledPopover className=\"formatter-popover\">\n        <DropdownList\n          options={formatLabels}\n          selectionIndex={selectionIndex}\n          displayOption={option => (option as TooltipFormat).label}\n          onOptionSelected={onSelectDisplayFormat}\n          light\n        />\n      </StyledPopover>\n    </Portaled>\n  );\n};\n\nexport interface OptionDropdownProps {\n  isOpened?: boolean;\n  column: string;\n  colMeta: ColMeta;\n  toggleMoreOptions: (column: string) => void;\n  sortTableColumn?: (sort: string) => void;\n  pinTableColumn: () => void;\n  copyTableColumn: () => void;\n  setDisplayFormat?: (displayFormat: any) => void;\n  sortMode?: string;\n  isSorted?: string;\n  isPinned?: boolean;\n}\n\nconst OptionDropdown = (props: OptionDropdownProps) => {\n  const {\n    isOpened,\n    column,\n    colMeta,\n    toggleMoreOptions,\n    sortTableColumn,\n    pinTableColumn,\n    copyTableColumn,\n    setDisplayFormat\n  } = props;\n  const [showFormatter, setShowFormatter] = useState(false);\n  const onOptionSelected: (v: TableOption) => void = useCallback(\n    ({value}) => {\n      switch (value) {\n        case TABLE_OPTION.SORT_ASC:\n          sortTableColumn?.(SORT_ORDER.ASCENDING);\n          break;\n        case TABLE_OPTION.SORT_DES:\n          sortTableColumn?.(SORT_ORDER.DESCENDING);\n          break;\n        case TABLE_OPTION.UNSORT:\n          sortTableColumn?.(SORT_ORDER.UNSORT);\n          break;\n        case TABLE_OPTION.PIN:\n          pinTableColumn();\n          break;\n        case TABLE_OPTION.UNPIN:\n          pinTableColumn();\n          break;\n        case TABLE_OPTION.COPY:\n          copyTableColumn();\n          break;\n        case TABLE_OPTION.FORMAT_COLUMN:\n          setShowFormatter(true);\n          return;\n        default:\n          break;\n      }\n\n      toggleMoreOptions(column);\n    },\n    [column, sortTableColumn, pinTableColumn, copyTableColumn, toggleMoreOptions]\n  );\n\n  const TABLE_OPTION_LIST_ICONS = {\n    Pin,\n    ArrowDown,\n    ArrowUp,\n    Clipboard,\n    Cancel,\n    Hash\n  };\n\n  const formatLabels = getFieldFormatLabels(colMeta[column].type);\n  const options = TABLE_OPTION_LIST.filter(op => {\n    // cant use conditions because it creates a circular dependency\n    // TODO: move condition clause out of default-settings TABLE_OPTION_LIST\n    const validToFormat = op.value !== TABLE_OPTION.FORMAT_COLUMN || formatLabels.length;\n    return (!op.condition || op.condition(props)) && validToFormat;\n  }).map(op => ({\n    ...op,\n    icon: TABLE_OPTION_LIST_ICONS[op.icon]\n  }));\n\n  const onClose = useCallback(() => {\n    setShowFormatter(false);\n    toggleMoreOptions(column);\n  }, [column, toggleMoreOptions]);\n\n  return (\n    <Portaled right={120} top={20} isOpened={isOpened} onClose={onClose}>\n      <StyledOptionsDropdown className=\"more-options\">\n        <DropdownList\n          displayOption={d => (d as TableOption).display}\n          options={options}\n          customListItemComponent={ListItem}\n          onOptionSelected={onOptionSelected}\n          light\n        />\n        <FormatterDropdown\n          left={120}\n          top={-10}\n          isOpened={Boolean(isOpened && showFormatter)}\n          formatLabels={formatLabels}\n          displayFormat={colMeta[column]?.displayFormat}\n          setDisplayFormat={setDisplayFormat}\n          onClose={onClose}\n        />\n      </StyledOptionsDropdown>\n    </Portaled>\n  );\n};\n\nexport default OptionDropdown;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/dataset-label.js

@@ -0,0 +1,22 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { CenterFlexbox, DatasetSquare } from './styled-components';
+var DatasetName = styled.div.attrs({
+  className: 'dataset-name'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  font-weight: 500;\n  font-size: 12px;\n  color: ", ";\n  white-space: nowrap;\n"])), function (props) {
+  return props.theme.titleColorLT;
+});
+var DatasetLabel = function DatasetLabel(_ref) {
+  var dataset = _ref.dataset;
+  return /*#__PURE__*/React.createElement(CenterFlexbox, null, /*#__PURE__*/React.createElement(DatasetSquare, {
+    className: "dataset-color",
+    backgroundColor: dataset.color
+  }), /*#__PURE__*/React.createElement(DatasetName, null, dataset.label));
+};
+export default DatasetLabel;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/common/dnd-layer-items.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { restrictToVerticalAxis } from '@dnd-kit/modifiers';
+export var DND_MODIFIERS = [restrictToVerticalAxis];
+export var DND_EMPTY_MODIFIERS = [];
+export var SORTABLE_SIDE_PANEL_TYPE = 'root';
+export var DROPPABLE_MAP_CONTAINER_TYPE = 'map';
+export var SORTABLE_LAYER_TYPE = 'layer';
+export var SORTABLE_LAYER_GROUP_TYPE = 'layerGroup';
+export var SORTABLE_LAYER_GROUP_DROPPABLE_TYPE = 'droppable-layer-group';
+export var SORTABLE_EFFECT_PANEL_TYPE = 'root';
+export var SORTABLE_EFFECT_TYPE = 'effect';
+export var SORTABLE_LAYER_END_PLACEHOLDER = '__layer-end-placeholder__';
+export var SORTABLE_LAYER_END_TYPE = 'layer-end-placeholder';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/common/error-boundary.js

@@ -0,0 +1,55 @@
+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";
+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 from 'react';
+import console from 'global/console';
+var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
+  function ErrorBoundary() {
+    var _this;
+    _classCallCheck(this, ErrorBoundary);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, ErrorBoundary, [].concat(args));
+    _defineProperty(_this, "state", {
+      hasError: false
+    });
+    return _this;
+  }
+  _inherits(ErrorBoundary, _React$Component);
+  return _createClass(ErrorBoundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error, errorInfo) {
+      // You can also log the error to an error reporting service
+      console.error(error, errorInfo);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      if (this.state.hasError) {
+        // You can render any custom fallback UI
+        return /*#__PURE__*/React.createElement("h1", null, "Something went wrong.");
+      }
+      return this.props.children;
+    }
+  }], [{
+    key: "getDerivedStateFromError",
+    value: function getDerivedStateFromError(error) {
+      // Update state so the next render will show the fallback UI.
+      return {
+        hasError: true,
+        error: error
+      };
+    }
+  }]);
+}(React.Component);
+export { ErrorBoundary as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,164 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+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 classnames from 'classnames';
+import React, { Component } from 'react';
+import styled from 'styled-components';
+import { createSelector } from 'reselect';
+import { notNullorUndefined, toArray } from '@kepler.gl/common-utils';
+import ItemSelector from './item-selector/item-selector';
+import { classList } from './item-selector/dropdown-list';
+import FieldTokenFactory from '../common/field-token';
+var defaultDisplayOption = function defaultDisplayOption(d) {
+  return d.displayName || d.name;
+};
+var defaultValueOption = function defaultValueOption(d) {
+  return d.name;
+};
+var StyledToken = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: inline-block;\n  margin: 0 ", "px 0 0;\n"])), function (props) {
+  return props.theme.fieldTokenRightMargin;
+});
+var StyledFieldListItem = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  line-height: 0;\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n"])));
+var StyledFieldSelector = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  .item-selector__dropdown {\n    // smaller padding on the side to accomodate field token\n    padding: 0 6px;\n  }\n"])));
+FieldListItemFactoryFactory.deps = [FieldTokenFactory];
+// custom list Item
+export function FieldListItemFactoryFactory(FieldToken) {
+  var FieldListItemFactory = function FieldListItemFactory() {
+    var showToken = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    var FieldListItem = function FieldListItem(_ref) {
+      var value = _ref.value,
+        _ref$displayOption = _ref.displayOption,
+        displayOption = _ref$displayOption === void 0 ? defaultDisplayOption : _ref$displayOption;
+      return /*#__PURE__*/React.createElement(StyledFieldListItem, {
+        className: "field-selector_list-item"
+      }, showToken ? /*#__PURE__*/React.createElement(StyledToken, null, /*#__PURE__*/React.createElement(FieldToken, {
+        type: value.type
+      })) : null, /*#__PURE__*/React.createElement("span", {
+        className: classList.listItemAnchor
+      }, displayOption(value)));
+    };
+    return FieldListItem;
+  };
+  return FieldListItemFactory;
+}
+var SuggestedFieldHeader = function SuggestedFieldHeader() {
+  return /*#__PURE__*/React.createElement("div", null, "Suggested Field");
+};
+function noop() {
+  return;
+}
+function FieldSelectorFactory(FieldListItemFactory) {
+  var FieldSelector = /*#__PURE__*/function (_Component) {
+    function FieldSelector() {
+      var _this;
+      _classCallCheck(this, FieldSelector);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, FieldSelector, [].concat(args));
+      _defineProperty(_this, "fieldsSelector", function (props) {
+        return props.fields;
+      });
+      _defineProperty(_this, "valueSelector", function (props) {
+        return props.value;
+      });
+      _defineProperty(_this, "filteredFieldsSelector", createSelector(_this.fieldsSelector, _this.valueSelector, function (fields, value) {
+        return fields.filter(function (field) {
+          return !toArray(value).find(function (d) {
+            return d.name ? d.name === field.name : d === field.name;
+          });
+        });
+      }));
+      _defineProperty(_this, "filterFieldTypesSelector", function (props) {
+        return props.filterFieldTypes;
+      });
+      _defineProperty(_this, "showTokenSelector", function (props) {
+        return props.showToken;
+      });
+      _defineProperty(_this, "selectedItemsSelector", createSelector(_this.fieldsSelector, _this.valueSelector, function (fields, value) {
+        return toArray(value).map(function (d) {
+          return fields.find(function (f) {
+            return notNullorUndefined(d) && d.name ? d.name === defaultValueOption(f) : d === defaultValueOption(f);
+          });
+        }).filter(function (d) {
+          return d;
+        });
+      }));
+      _defineProperty(_this, "fieldOptionsSelector", createSelector(_this.filteredFieldsSelector, _this.filterFieldTypesSelector, function (fields, filterFieldTypes) {
+        if (!filterFieldTypes) {
+          return fields;
+        }
+        var filters = Array.isArray(filterFieldTypes) ? filterFieldTypes : [filterFieldTypes];
+        return fields.filter(function (f) {
+          return filters.includes(f.type);
+        });
+      }));
+      // @ts-ignore Fix later
+      _defineProperty(_this, "fieldListItemSelector", createSelector(_this.showTokenSelector, FieldListItemFactory));
+      return _this;
+    }
+    _inherits(FieldSelector, _Component);
+    return _createClass(FieldSelector, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/React.createElement(StyledFieldSelector, {
+          className: classnames('field-selector', this.props.className)
+        }, /*#__PURE__*/React.createElement(ItemSelector, {
+          getOptionValue: function getOptionValue(d) {
+            return d;
+          },
+          disabled: this.props.disabled,
+          closeOnSelect: this.props.closeOnSelect,
+          displayOption: defaultDisplayOption,
+          filterOption: "displayName",
+          fixedOptions: this.props.suggested,
+          inputTheme: this.props.inputTheme,
+          size: this.props.size,
+          isError: this.props.error,
+          selectedItems: this.selectedItemsSelector(this.props),
+          erasable: this.props.erasable
+          // @ts-ignore - Argument of type 'Readonly<FieldSelectorFactoryProps>' is not assignable to parameter of type 'never'
+          ,
+          options: this.fieldOptionsSelector(this.props),
+          multiSelect: this.props.multiSelect,
+          placeholder: this.props.placeholder,
+          placement: this.props.placement,
+          onChange: this.props.onSelect,
+          reorderItems: this.props.reorderItems,
+          DropDownLineItemRenderComponent: this.fieldListItemSelector(this.props),
+          DropdownHeaderComponent: this.props.suggested ? SuggestedFieldHeader : null,
+          CustomChickletComponent: this.props.CustomChickletComponent
+        }));
+      }
+    }]);
+  }(Component); // @ts-ignore: Fix me
+  _defineProperty(FieldSelector, "defaultProps", {
+    erasable: true,
+    disabled: false,
+    error: false,
+    fields: [],
+    onSelect: noop,
+    reorderItems: noop,
+    placement: 'bottom',
+    value: null,
+    multiSelect: false,
+    closeOnSelect: true,
+    showToken: true,
+    placeholder: 'placeholder.selectField',
+    className: ''
+  });
+  return FieldSelector;
+}
+FieldSelectorFactory.deps = [FieldListItemFactoryFactory];
+export default FieldSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["classnames","React","Component","styled","createSelector","notNullorUndefined","toArray","ItemSelector","classList","FieldTokenFactory","defaultDisplayOption","d","displayName","name","defaultValueOption","StyledToken","div","_templateObject","_taggedTemplateLiteral","props","theme","fieldTokenRightMargin","StyledFieldListItem","_templateObject2","StyledFieldSelector","_templateObject3","FieldListItemFactoryFactory","deps","FieldToken","FieldListItemFactory","showToken","arguments","length","undefined","FieldListItem","_ref","value","_ref$displayOption","displayOption","createElement","className","type","listItemAnchor","SuggestedFieldHeader","noop","FieldSelectorFactory","FieldSelector","_Component","_this","_classCallCheck","_len","args","Array","_key","_callSuper","concat","_defineProperty","fields","fieldsSelector","valueSelector","filter","field","find","filterFieldTypes","map","f","filteredFieldsSelector","filterFieldTypesSelector","filters","isArray","includes","showTokenSelector","_inherits","_createClass","key","render","getOptionValue","disabled","closeOnSelect","filterOption","fixedOptions","suggested","inputTheme","size","isError","error","selectedItems","selectedItemsSelector","erasable","options","fieldOptionsSelector","multiSelect","placeholder","placement","onChange","onSelect","reorderItems","DropDownLineItemRenderComponent","fieldListItemSelector","DropdownHeaderComponent","CustomChickletComponent"],"sources":["../../../src/common/field-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport classnames from 'classnames';\nimport React, {Component, ComponentType} from 'react';\nimport styled from 'styled-components';\nimport {createSelector} from 'reselect';\n\nimport {Field, TooltipField} from '@kepler.gl/types';\nimport {notNullorUndefined, toArray} from '@kepler.gl/common-utils';\n\nimport ItemSelector from './item-selector/item-selector';\nimport {classList} from './item-selector/dropdown-list';\nimport FieldTokenFactory from '../common/field-token';\n\nconst defaultDisplayOption = (d: Field) => d.displayName || d.name;\nconst defaultValueOption = (d: Field) => d.name;\n\nconst StyledToken = styled.div`\n  display: inline-block;\n  margin: 0 ${props => props.theme.fieldTokenRightMargin}px 0 0;\n`;\nconst StyledFieldListItem = styled.div`\n  line-height: 0;\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n`;\nconst StyledFieldSelector = styled.div`\n  .item-selector__dropdown {\n    // smaller padding on the side to accomodate field token\n    padding: 0 6px;\n  }\n`;\nexport type FieldListItemFactoryProps = {\n  value: Field;\n  displayOption: (field: Field) => string;\n};\n\nFieldListItemFactoryFactory.deps = [FieldTokenFactory];\n// custom list Item\nexport function FieldListItemFactoryFactory(FieldToken) {\n  const FieldListItemFactory = (showToken = true) => {\n    const FieldListItem = ({\n      value,\n      displayOption = defaultDisplayOption\n    }: FieldListItemFactoryProps) => (\n      <StyledFieldListItem className=\"field-selector_list-item\">\n        {showToken ? (\n          <StyledToken>\n            <FieldToken type={value.type} />\n          </StyledToken>\n        ) : null}\n        <span className={classList.listItemAnchor}>{displayOption(value)}</span>\n      </StyledFieldListItem>\n    );\n    return FieldListItem;\n  };\n  return FieldListItemFactory;\n}\n\nconst SuggestedFieldHeader = () => <div>Suggested Field</div>;\n\nexport type MinimalField = {name: string; displayName: string; format: string; type?: string};\nexport type FieldType = string | TooltipField | Field;\nexport type FieldValue = string | {name: string} | string[] | {name: string}[];\n\nexport type FieldSelectorProps<Option extends MinimalField> = {\n  id?: string;\n  fields: Option[];\n  onSelect: (\n    items:\n      | ReadonlyArray<string | number | boolean | object>\n      | string\n      | number\n      | boolean\n      | object\n      | null\n  ) => void;\n  value?: FieldValue | null;\n  filterFieldTypes?: string | string[];\n  inputTheme?: string;\n  placement?: string;\n  placeholder?: string;\n  erasable?: boolean;\n  disabled?: boolean;\n  error?: boolean;\n  multiSelect?: boolean;\n  closeOnSelect?: boolean;\n  showToken?: boolean;\n  suggested?: Option[] | null;\n  CustomChickletComponent?: ComponentType<any>;\n  size?: string;\n  reorderItems?: (newOrder: any) => void;\n  className?: string;\n};\n\nfunction noop() {\n  return;\n}\nfunction FieldSelectorFactory(\n  FieldListItemFactory: ReturnType<typeof FieldListItemFactoryFactory>\n): ComponentType<FieldSelectorProps<MinimalField>> {\n  class FieldSelector extends Component<FieldSelectorProps<MinimalField>> {\n    static defaultProps = {\n      erasable: true,\n      disabled: false,\n      error: false,\n      fields: [],\n      onSelect: noop,\n      reorderItems: noop,\n      placement: 'bottom',\n      value: null,\n      multiSelect: false,\n      closeOnSelect: true,\n      showToken: true,\n      placeholder: 'placeholder.selectField',\n      className: ''\n    };\n\n    fieldsSelector = props => props.fields;\n    valueSelector = props => props.value;\n    filteredFieldsSelector = createSelector(\n      this.fieldsSelector,\n      this.valueSelector,\n      (fields, value) => {\n        return fields.filter(\n          field => !toArray(value).find(d => (d.name ? d.name === field.name : d === field.name))\n        );\n      }\n    );\n    filterFieldTypesSelector = props => props.filterFieldTypes;\n    showTokenSelector = props => props.showToken;\n\n    selectedItemsSelector = createSelector(\n      this.fieldsSelector,\n      this.valueSelector,\n      (fields, value) =>\n        toArray(value)\n          .map(d =>\n            fields.find(f =>\n              notNullorUndefined(d) && d.name\n                ? d.name === defaultValueOption(f)\n                : d === defaultValueOption(f)\n            )\n          )\n          .filter(d => d)\n    );\n\n    fieldOptionsSelector = createSelector(\n      this.filteredFieldsSelector,\n      this.filterFieldTypesSelector,\n      (fields, filterFieldTypes) => {\n        if (!filterFieldTypes) {\n          return fields;\n        }\n        const filters = Array.isArray(filterFieldTypes) ? filterFieldTypes : [filterFieldTypes];\n        return fields.filter(f => filters.includes(f.type));\n      }\n    );\n\n    // @ts-ignore Fix later\n    fieldListItemSelector = createSelector(this.showTokenSelector, FieldListItemFactory);\n\n    render() {\n      return (\n        <StyledFieldSelector className={classnames('field-selector', this.props.className)}>\n          <ItemSelector\n            getOptionValue={d => d}\n            disabled={this.props.disabled}\n            closeOnSelect={this.props.closeOnSelect}\n            displayOption={defaultDisplayOption}\n            filterOption=\"displayName\"\n            fixedOptions={this.props.suggested}\n            inputTheme={this.props.inputTheme}\n            size={this.props.size}\n            isError={this.props.error}\n            selectedItems={this.selectedItemsSelector(this.props)}\n            erasable={this.props.erasable}\n            // @ts-ignore - Argument of type 'Readonly<FieldSelectorFactoryProps>' is not assignable to parameter of type 'never'\n            options={this.fieldOptionsSelector(this.props)}\n            multiSelect={this.props.multiSelect}\n            placeholder={this.props.placeholder}\n            placement={this.props.placement}\n            onChange={this.props.onSelect}\n            reorderItems={this.props.reorderItems}\n            DropDownLineItemRenderComponent={this.fieldListItemSelector(this.props)}\n            DropdownHeaderComponent={this.props.suggested ? SuggestedFieldHeader : null}\n            CustomChickletComponent={this.props.CustomChickletComponent}\n          />\n        </StyledFieldSelector>\n      );\n    }\n  }\n\n  // @ts-ignore: Fix me\n  return FieldSelector;\n}\n\nFieldSelectorFactory.deps = [FieldListItemFactoryFactory];\nexport default FieldSelectorFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/field-token.js

@@ -0,0 +1,38 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { FIELD_TYPE_DISPLAY, FIELD_COLORS } from '@kepler.gl/constants';
+var FieldTag = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  background-color: rgba(", ", 0.2);\n  border-radius: 2px;\n  border: 1px solid rgb(", ");\n  color: rgb(", ");\n  display: inline-block;\n  font-size: 10px;\n  font-weight: 400;\n  padding: 0 5px;\n  text-align: center;\n  width: ", "px;\n  line-height: ", "px;\n"])), function (props) {
+  return props.color;
+}, function (props) {
+  return props.color;
+}, function (props) {
+  return props.color;
+}, function (props) {
+  return props.theme.fieldTokenWidth;
+}, function (props) {
+  return props.theme.fieldTokenHeight;
+});
+function FieldTokenFactory(fieldTypeDisplay, fieldColors) {
+  var FieldToken = function FieldToken(_ref) {
+    var _fieldTypeDisplay$typ, _fieldTypeDisplay$typ2;
+    var type = _ref.type;
+    return /*#__PURE__*/React.createElement(FieldTag, {
+      color: ((_fieldTypeDisplay$typ = fieldTypeDisplay[type]) === null || _fieldTypeDisplay$typ === void 0 ? void 0 : _fieldTypeDisplay$typ.color) || fieldColors["default"]
+    }, (_fieldTypeDisplay$typ2 = fieldTypeDisplay[type]) === null || _fieldTypeDisplay$typ2 === void 0 ? void 0 : _fieldTypeDisplay$typ2.label);
+  };
+  return FieldToken;
+}
+function getFieldTypes() {
+  return FIELD_TYPE_DISPLAY;
+}
+function getFieldColors() {
+  return FIELD_COLORS;
+}
+FieldTokenFactory.deps = [getFieldTypes, getFieldColors];
+export default FieldTokenFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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