@kepler.gl/components 3.0.0-alpha.0

package/dist/common/field-selector.js

@@ -0,0 +1,220 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FieldListItemFactoryFactory = FieldListItemFactoryFactory;
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reselect = require("reselect");
+
+var _utils = require("@kepler.gl/utils");
+
+var _itemSelector = _interopRequireDefault(require("./item-selector/item-selector"));
+
+var _dropdownList = require("./item-selector/dropdown-list");
+
+var _fieldToken = _interopRequireDefault(require("../common/field-token"));
+
+var _templateObject, _templateObject2;
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var defaultDisplayOption = function defaultDisplayOption(d) {
+  return d.displayName || d.name;
+};
+
+var defaultValueOption = function defaultValueOption(d) {
+  return d.name;
+};
+
+var StyledToken = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: inline-block;\n  margin: 0 ", "px 0 0;\n"])), function (props) {
+  return props.theme.fieldTokenRightMargin;
+});
+
+var StyledFieldListItem = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  line-height: 0;\n"])));
+
+FieldListItemFactoryFactory.deps = [_fieldToken["default"]]; // custom list Item
+
+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["default"].createElement(StyledFieldListItem, {
+        className: "field-selector_list-item"
+      }, showToken ? /*#__PURE__*/_react["default"].createElement(StyledToken, null, /*#__PURE__*/_react["default"].createElement(FieldToken, {
+        type: value.type
+      })) : null, /*#__PURE__*/_react["default"].createElement("span", {
+        className: _dropdownList.classList.listItemAnchor
+      }, displayOption(value)));
+    };
+
+    return FieldListItem;
+  };
+
+  return FieldListItemFactory;
+}
+
+var SuggestedFieldHeader = function SuggestedFieldHeader() {
+  return /*#__PURE__*/_react["default"].createElement("div", null, "Suggested Field");
+};
+
+function FieldSelectorFactory(FieldListItemFactory) {
+  var FieldSelector = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(FieldSelector, _Component);
+
+    var _super = _createSuper(FieldSelector);
+
+    function FieldSelector() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, FieldSelector);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "fieldsSelector", function (props) {
+        return props.fields;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "valueSelector", function (props) {
+        return props.value;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filteredFieldsSelector", (0, _reselect.createSelector)(_this.fieldsSelector, _this.valueSelector, function (fields, value) {
+        return fields.filter(function (field) {
+          return !(0, _utils.toArray)(value).find(function (d) {
+            return d.name ? d.name === field.name : d === field.name;
+          });
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filterFieldTypesSelector", function (props) {
+        return props.filterFieldTypes;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "showTokenSelector", function (props) {
+        return props.showToken;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "selectedItemsSelector", (0, _reselect.createSelector)(_this.fieldsSelector, _this.valueSelector, function (fields, value) {
+        return (0, _utils.toArray)(value).map(function (d) {
+          return fields.find(function (f) {
+            return (0, _utils.notNullorUndefined)(d) && d.name ? d.name === defaultValueOption(f) : d === defaultValueOption(f);
+          });
+        }).filter(function (d) {
+          return d;
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "fieldOptionsSelector", (0, _reselect.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);
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "fieldListItemSelector", (0, _reselect.createSelector)(_this.showTokenSelector, FieldListItemFactory));
+      return _this;
+    }
+
+    (0, _createClass2["default"])(FieldSelector, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          className: "field-selector"
+        }, /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], {
+          getOptionValue: function getOptionValue(d) {
+            return d;
+          },
+          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,
+          options: this.fieldOptionsSelector(this.props),
+          multiSelect: this.props.multiSelect,
+          placeholder: this.props.placeholder,
+          placement: this.props.placement,
+          onChange: this.props.onSelect,
+          DropDownLineItemRenderComponent: this.fieldListItemSelector(this.props),
+          DropdownHeaderComponent: this.props.suggested ? SuggestedFieldHeader : null,
+          CustomChickletComponent: this.props.CustomChickletComponent
+        }));
+      }
+    }]);
+    return FieldSelector;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(FieldSelector, "defaultProps", {
+    erasable: true,
+    error: false,
+    fields: [],
+    onSelect: function onSelect() {},
+    placement: 'bottom',
+    value: null,
+    multiSelect: false,
+    closeOnSelect: true,
+    showToken: true,
+    placeholder: 'placeholder.selectField'
+  });
+  return FieldSelector;
+}
+
+FieldSelectorFactory.deps = [FieldListItemFactoryFactory];
+var _default = FieldSelectorFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/common/field-selector.tsx"],"names":["defaultDisplayOption","d","displayName","name","defaultValueOption","StyledToken","styled","div","props","theme","fieldTokenRightMargin","StyledFieldListItem","FieldListItemFactoryFactory","deps","FieldTokenFactory","FieldToken","FieldListItemFactory","showToken","FieldListItem","value","displayOption","type","classList","listItemAnchor","SuggestedFieldHeader","FieldSelectorFactory","FieldSelector","fields","fieldsSelector","valueSelector","filter","field","find","filterFieldTypes","map","f","filteredFieldsSelector","filterFieldTypesSelector","filters","Array","isArray","includes","showTokenSelector","closeOnSelect","suggested","inputTheme","size","error","selectedItemsSelector","erasable","fieldOptionsSelector","multiSelect","placeholder","placement","onSelect","fieldListItemSelector","CustomChickletComponent","Component"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AAGA;;AAEA;;AACA;;AACA;;;;;;;;AAEA,IAAMA,oBAAoB,GAAG,SAAvBA,oBAAuB,CAACC,CAAD;AAAA,SAAcA,CAAC,CAACC,WAAF,IAAiBD,CAAC,CAACE,IAAjC;AAAA,CAA7B;;AACA,IAAMC,kBAAkB,GAAG,SAArBA,kBAAqB,CAACH,CAAD;AAAA,SAAcA,CAAC,CAACE,IAAhB;AAAA,CAA3B;;AAEA,IAAME,WAAW,GAAGC,6BAAOC,GAAV,4IAEH,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYC,qBAAhB;AAAA,CAFF,CAAjB;;AAIA,IAAMC,mBAAmB,GAAGL,6BAAOC,GAAV,6GAAzB;;AASAK,2BAA2B,CAACC,IAA5B,GAAmC,CAACC,sBAAD,CAAnC,C,CACA;;AACO,SAASF,2BAAT,CAAqCG,UAArC,EAAiD;AACtD,MAAMC,oBAAoB,GAAG,SAAvBA,oBAAuB,GAAsB;AAAA,QAArBC,SAAqB,uEAAT,IAAS;;AACjD,QAAMC,aAAa,GAAG,SAAhBA,aAAgB;AAAA,UACpBC,KADoB,QACpBA,KADoB;AAAA,oCAEpBC,aAFoB;AAAA,UAEpBA,aAFoB,mCAEJpB,oBAFI;AAAA,0BAIpB,gCAAC,mBAAD;AAAqB,QAAA,SAAS,EAAC;AAA/B,SACGiB,SAAS,gBACR,gCAAC,WAAD,qBACE,gCAAC,UAAD;AAAY,QAAA,IAAI,EAAEE,KAAK,CAACE;AAAxB,QADF,CADQ,GAIN,IALN,eAME;AAAM,QAAA,SAAS,EAAEC,wBAAUC;AAA3B,SAA4CH,aAAa,CAACD,KAAD,CAAzD,CANF,CAJoB;AAAA,KAAtB;;AAaA,WAAOD,aAAP;AACD,GAfD;;AAgBA,SAAOF,oBAAP;AACD;;AAED,IAAMQ,oBAAoB,GAAG,SAAvBA,oBAAuB;AAAA,sBAAM,+DAAN;AAAA,CAA7B;;AA4CA,SAASC,oBAAT,CACET,oBADF,EAE4C;AAAA,MACpCU,aADoC;AAAA;;AAAA;;AAAA;AAAA;;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA,yGAevB,UAAAlB,KAAK;AAAA,eAAIA,KAAK,CAACmB,MAAV;AAAA,OAfkB;AAAA,wGAgBxB,UAAAnB,KAAK;AAAA,eAAIA,KAAK,CAACW,KAAV;AAAA,OAhBmB;AAAA,iHAiBf,8BACvB,MAAKS,cADkB,EAEvB,MAAKC,aAFkB,EAGvB,UAACF,MAAD,EAASR,KAAT,EAAmB;AACjB,eAAOQ,MAAM,CAACG,MAAP,CACL,UAAAC,KAAK;AAAA,iBAAI,CAAC,oBAAQZ,KAAR,EAAea,IAAf,CAAoB,UAAA/B,CAAC;AAAA,mBAAKA,CAAC,CAACE,IAAF,GAASF,CAAC,CAACE,IAAF,KAAW4B,KAAK,CAAC5B,IAA1B,GAAiCF,CAAC,KAAK8B,KAAK,CAAC5B,IAAlD;AAAA,WAArB,CAAL;AAAA,SADA,CAAP;AAGD,OAPsB,CAjBe;AAAA,mHA0Bb,UAAAK,KAAK;AAAA,eAAIA,KAAK,CAACyB,gBAAV;AAAA,OA1BQ;AAAA,4GA2BpB,UAAAzB,KAAK;AAAA,eAAIA,KAAK,CAACS,SAAV;AAAA,OA3Be;AAAA,gHA6BhB,8BACtB,MAAKW,cADiB,EAEtB,MAAKC,aAFiB,EAGtB,UAACF,MAAD,EAASR,KAAT;AAAA,eACE,oBAAQA,KAAR,EACGe,GADH,CACO,UAAAjC,CAAC;AAAA,iBACJ0B,MAAM,CAACK,IAAP,CAAY,UAAAG,CAAC;AAAA,mBACX,+BAAmBlC,CAAnB,KAAyBA,CAAC,CAACE,IAA3B,GACIF,CAAC,CAACE,IAAF,KAAWC,kBAAkB,CAAC+B,CAAD,CADjC,GAEIlC,CAAC,KAAKG,kBAAkB,CAAC+B,CAAD,CAHjB;AAAA,WAAb,CADI;AAAA,SADR,EAQGL,MARH,CAQU,UAAA7B,CAAC;AAAA,iBAAIA,CAAJ;AAAA,SARX,CADF;AAAA,OAHsB,CA7BgB;AAAA,+GA4CjB,8BACrB,MAAKmC,sBADgB,EAErB,MAAKC,wBAFgB,EAGrB,UAACV,MAAD,EAASM,gBAAT,EAA8B;AAC5B,YAAI,CAACA,gBAAL,EAAuB;AACrB,iBAAON,MAAP;AACD;;AACD,YAAMW,OAAO,GAAGC,KAAK,CAACC,OAAN,CAAcP,gBAAd,IAAkCA,gBAAlC,GAAqD,CAACA,gBAAD,CAArE;AACA,eAAON,MAAM,CAACG,MAAP,CAAc,UAAAK,CAAC;AAAA,iBAAIG,OAAO,CAACG,QAAR,CAAiBN,CAAC,CAACd,IAAnB,CAAJ;AAAA,SAAf,CAAP;AACD,OAToB,CA5CiB;AAAA,gHAwDhB,8BAAe,MAAKqB,iBAApB,EAAuC1B,oBAAvC,CAxDgB;AAAA;AAAA;;AAAA;AAAA;AAAA,aA0DxC,kBAAS;AACP,4BACE;AAAK,UAAA,SAAS,EAAC;AAAf,wBACE,gCAAC,wBAAD;AACE,UAAA,cAAc,EAAE,wBAAAf,CAAC;AAAA,mBAAIA,CAAJ;AAAA,WADnB;AAEE,UAAA,aAAa,EAAE,KAAKO,KAAL,CAAWmC,aAF5B;AAGE,UAAA,aAAa,EAAE3C,oBAHjB;AAIE,UAAA,YAAY,EAAC,aAJf;AAKE,UAAA,YAAY,EAAE,KAAKQ,KAAL,CAAWoC,SAL3B;AAME,UAAA,UAAU,EAAE,KAAKpC,KAAL,CAAWqC,UANzB;AAOE,UAAA,IAAI,EAAE,KAAKrC,KAAL,CAAWsC,IAPnB;AAQE,UAAA,OAAO,EAAE,KAAKtC,KAAL,CAAWuC,KARtB;AASE,UAAA,aAAa,EAAE,KAAKC,qBAAL,CAA2B,KAAKxC,KAAhC,CATjB;AAUE,UAAA,QAAQ,EAAE,KAAKA,KAAL,CAAWyC,QAVvB;AAWE,UAAA,OAAO,EAAE,KAAKC,oBAAL,CAA0B,KAAK1C,KAA/B,CAXX;AAYE,UAAA,WAAW,EAAE,KAAKA,KAAL,CAAW2C,WAZ1B;AAaE,UAAA,WAAW,EAAE,KAAK3C,KAAL,CAAW4C,WAb1B;AAcE,UAAA,SAAS,EAAE,KAAK5C,KAAL,CAAW6C,SAdxB;AAeE,UAAA,QAAQ,EAAE,KAAK7C,KAAL,CAAW8C,QAfvB;AAgBE,UAAA,+BAA+B,EAAE,KAAKC,qBAAL,CAA2B,KAAK/C,KAAhC,CAhBnC;AAiBE,UAAA,uBAAuB,EAAE,KAAKA,KAAL,CAAWoC,SAAX,GAAuBpB,oBAAvB,GAA8C,IAjBzE;AAkBE,UAAA,uBAAuB,EAAE,KAAKhB,KAAL,CAAWgD;AAlBtC,UADF,CADF;AAwBD;AAnFuC;AAAA;AAAA,IACdC,gBADc;;AAAA,mCACpC/B,aADoC,kBAElB;AACpBuB,IAAAA,QAAQ,EAAE,IADU;AAEpBF,IAAAA,KAAK,EAAE,KAFa;AAGpBpB,IAAAA,MAAM,EAAE,EAHY;AAIpB2B,IAAAA,QAAQ,EAAE,oBAAM,CAAE,CAJE;AAKpBD,IAAAA,SAAS,EAAE,QALS;AAMpBlC,IAAAA,KAAK,EAAE,IANa;AAOpBgC,IAAAA,WAAW,EAAE,KAPO;AAQpBR,IAAAA,aAAa,EAAE,IARK;AASpB1B,IAAAA,SAAS,EAAE,IATS;AAUpBmC,IAAAA,WAAW,EAAE;AAVO,GAFkB;AAqF1C,SAAO1B,aAAP;AACD;;AAEDD,oBAAoB,CAACZ,IAArB,GAA4B,CAACD,2BAAD,CAA5B;eACea,oB","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {Component, ComponentType} from 'react';\nimport styled from 'styled-components';\nimport {createSelector} from 'reselect';\n\nimport {Field} from '@kepler.gl/types';\nimport {notNullorUndefined, toArray} from '@kepler.gl/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`;\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\ntype FieldType =\n  | string\n  | string[]\n  | {\n      name: string;\n      format: string | null;\n    }[]\n  | {\n      format?: string;\n      id?: string;\n      name?: string;\n      fieldIdx?: number;\n      type?: number;\n    }\n  | Field;\n\ninterface FieldSelectorFactoryProps {\n  fields?: FieldType[];\n  onSelect: (\n    items:\n      | ReadonlyArray<string | number | boolean | object>\n      | string\n      | number\n      | boolean\n      | object\n      | null\n  ) => void;\n  placement?: string;\n  value?: FieldType | null;\n  filterFieldTypes?: FieldType | FieldType[];\n  inputTheme?: string;\n  placeholder?: string;\n  erasable?: boolean;\n  error?: boolean;\n  multiSelect?: boolean;\n  closeOnSelect?: boolean;\n  showToken?: boolean;\n  suggested?: ReadonlyArray<string | number | boolean | object> | null;\n  CustomChickletComponent?: ComponentType;\n  size?: string;\n}\n\nfunction FieldSelectorFactory(\n  FieldListItemFactory: ReturnType<typeof FieldListItemFactoryFactory>\n): ComponentType<FieldSelectorFactoryProps> {\n  class FieldSelector extends Component<FieldSelectorFactoryProps> {\n    static defaultProps = {\n      erasable: true,\n      error: false,\n      fields: [],\n      onSelect: () => {},\n      placement: 'bottom',\n      value: null,\n      multiSelect: false,\n      closeOnSelect: true,\n      showToken: true,\n      placeholder: 'placeholder.selectField'\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    fieldListItemSelector = createSelector(this.showTokenSelector, FieldListItemFactory);\n\n    render() {\n      return (\n        <div className=\"field-selector\">\n          <ItemSelector\n            getOptionValue={d => d}\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            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            DropDownLineItemRenderComponent={this.fieldListItemSelector(this.props)}\n            DropdownHeaderComponent={this.props.suggested ? SuggestedFieldHeader : null}\n            CustomChickletComponent={this.props.CustomChickletComponent}\n          />\n        </div>\n      );\n    }\n  }\n  return FieldSelector;\n}\n\nFieldSelectorFactory.deps = [FieldListItemFactoryFactory];\nexport default FieldSelectorFactory;\n"]}

package/dist/common/field-token.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+export declare type FieldTokenProps = {
+    type: string;
+};
+declare function FieldTokenFactory(fieldTypeDisplay: ReturnType<typeof getFieldTypes>, fieldColors: ReturnType<typeof getFieldColors>): React.FC<FieldTokenProps>;
+declare namespace FieldTokenFactory {
+    var deps: (typeof getFieldTypes | typeof getFieldColors)[];
+}
+declare function getFieldTypes(): {
+    boolean: {
+        label: string;
+        color: string;
+    };
+    date: {
+        label: string;
+        color: string;
+    };
+    geojson: {
+        label: string;
+        color: string;
+    };
+    integer: {
+        label: string;
+        color: string;
+    };
+    real: {
+        label: string;
+        color: string;
+    };
+    string: {
+        label: string;
+        color: string;
+    };
+    timestamp: {
+        label: string;
+        color: string;
+    };
+    point: {
+        label: string;
+        color: string;
+    };
+};
+declare function getFieldColors(): {
+    default: string;
+};
+export default FieldTokenFactory;

package/dist/common/field-token.js

@@ -0,0 +1,70 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _templateObject;
+
+function FieldTokenFactory(fieldTypeDisplay, fieldColors) {
+  var FieldTag = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\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: 40px;\n    line-height: 20px;\n  "])), function (props) {
+    return props.color;
+  }, function (props) {
+    return props.color;
+  }, function (props) {
+    return props.color;
+  });
+
+  var FieldToken = function FieldToken(_ref) {
+    var type = _ref.type;
+    return /*#__PURE__*/_react["default"].createElement(FieldTag, {
+      color: fieldTypeDisplay[type] && fieldTypeDisplay[type].color || fieldColors["default"]
+    }, fieldTypeDisplay[type].label);
+  };
+
+  return FieldToken;
+}
+
+function getFieldTypes() {
+  return _constants.FIELD_TYPE_DISPLAY;
+}
+
+function getFieldColors() {
+  return _constants.FIELD_COLORS;
+}
+
+FieldTokenFactory.deps = [getFieldTypes, getFieldColors];
+var _default = FieldTokenFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/common/file-uploader/file-drop.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copied from https://github.com/sarink/react-file-drop
+ * For React 16.8 compatibility
+ */
+import React from 'react';
+import window from 'global/window';
+export declare type FileDropProps = {
+    dropEffect?: 'copy' | 'move' | 'link' | 'none';
+    frame?: typeof document | typeof window | HTMLElement;
+    className?: string;
+    targetClassName?: string;
+    draggingOverFrameClassName?: string;
+    draggingOverTargetClassName?: string;
+    onDragOver?: (event: any) => void;
+    onDragLeave?: (event: any) => void;
+    onDrop?: (fileList: FileList, event: any) => void;
+    onFrameDragEnter?: (event: any) => void;
+    onFrameDragLeave?: (event: any) => void;
+    onFrameDrop?: (event: any) => void;
+};
+/** @typedef {import('./file-drop').FileDropProps} FileDropProps */
+/** @augments React.PureComponent<FileDropProps> */
+declare class FileDrop extends React.PureComponent<FileDropProps> {
+    static isIE: () => any;
+    static eventHasFiles: (event: any) => boolean;
+    static defaultProps: {
+        dropEffect: string;
+        frame: any;
+        className: string;
+        targetClassName: string;
+        draggingOverFrameClassName: string;
+        draggingOverTargetClassName: string;
+    };
+    frameDragCounter: number;
+    state: {
+        draggingOverFrame: boolean;
+        draggingOverTarget: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    resetDragging: () => void;
+    handleWindowDragOverOrDrop: (event: any) => void;
+    handleFrameDrag: (event: any) => void;
+    handleFrameDrop: (event: any) => void;
+    handleDragOver: (event: any) => void;
+    handleDragLeave: (event: any) => void;
+    handleDrop: (event: any) => void;
+    stopFrameListeners: (frame: any) => void;
+    startFrameListeners: (frame: any) => void;
+    render(): JSX.Element;
+}
+export default FileDrop;