@kepler.gl/components 3.0.0-alpha.0

package/dist/side-panel/layer-manager.js

@@ -0,0 +1,225 @@
+// 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["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 _reactIntl = require("react-intl");
+
+var _localization = require("@kepler.gl/localization");
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _layerList = _interopRequireDefault(require("./layer-panel/layer-list"));
+
+var _datasetLayerGroup = _interopRequireDefault(require("./layer-panel/dataset-layer-group"));
+
+var _panelViewListToggle = _interopRequireDefault(require("./layer-panel/panel-view-list-toggle"));
+
+var _panelTitle = _interopRequireDefault(require("./panel-title"));
+
+var _datasetSection = _interopRequireDefault(require("./layer-panel/dataset-section"));
+
+var _addLayerButton = _interopRequireDefault(require("./layer-panel/add-layer-button"));
+
+var _itemSelector = _interopRequireDefault(require("../common/item-selector/item-selector"));
+
+var _styledComponents2 = require("../common/styled-components");
+
+var _constants = require("@kepler.gl/constants");
+
+var _templateObject;
+
+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; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var LayerHeader = _styledComponents["default"].div.attrs({
+  className: 'layer-manager-header'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  justify-content: space-between;\n  align-items: flex-start;\n  margin-top: 16px;\n"])));
+
+var LayerBlendingSelector = /*#__PURE__*/_react["default"].memo(function (_ref) {
+  var layerBlending = _ref.layerBlending,
+      updateLayerBlending = _ref.updateLayerBlending,
+      intl = _ref.intl;
+  var labeledLayerBlendings = Object.keys(_constants.LAYER_BLENDINGS).reduce(function (acc, current) {
+    return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, intl.formatMessage({
+      id: _constants.LAYER_BLENDINGS[current].label
+    }), current));
+  }, {});
+  var onChange = (0, _react.useCallback)(function (blending) {
+    return updateLayerBlending(labeledLayerBlendings[blending]);
+  }, [updateLayerBlending, labeledLayerBlendings]);
+  return /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents2.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: "layerBlending.title"
+  })), /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], {
+    selectedItems: intl.formatMessage({
+      id: _constants.LAYER_BLENDINGS[layerBlending].label
+    }),
+    options: Object.keys(labeledLayerBlendings),
+    multiSelect: false,
+    searchable: false,
+    onChange: onChange
+  }));
+});
+
+LayerBlendingSelector.displayName = 'LayerBlendingSelector';
+LayerManagerFactory.deps = [_layerList["default"], _datasetLayerGroup["default"], _panelViewListToggle["default"], _panelTitle["default"], _datasetSection["default"], _addLayerButton["default"]];
+
+function LayerManagerFactory(LayerList, DatasetLayerGroup, PanelViewListToggle, PanelTitle, DatasetSection, AddLayerButton) {
+  var LayerManager = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(LayerManager, _Component);
+
+    var _super = _createSuper(LayerManager);
+
+    function LayerManager() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, LayerManager);
+
+      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), "_addEmptyNewLayer", function (dataset) {
+        var visStateActions = _this.props.visStateActions;
+        visStateActions.addLayer(undefined, dataset);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_toggleLayerPanelListView", function (listView) {
+        var uiStateActions = _this.props.uiStateActions;
+        uiStateActions.toggleLayerPanelListView(listView);
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(LayerManager, [{
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            layers = _this$props.layers,
+            datasets = _this$props.datasets,
+            intl = _this$props.intl,
+            layerOrder = _this$props.layerOrder,
+            showAddDataModal = _this$props.showAddDataModal,
+            updateTableColor = _this$props.updateTableColor,
+            showDatasetTable = _this$props.showDatasetTable,
+            removeDataset = _this$props.removeDataset,
+            uiStateActions = _this$props.uiStateActions,
+            visStateActions = _this$props.visStateActions,
+            layerPanelListView = _this$props.layerPanelListView,
+            panelMetadata = _this$props.panelMetadata;
+        var defaultDataset = Object.keys(datasets)[0];
+        var isSortByDatasetMode = layerPanelListView === 'sortByDataset';
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          className: "layer-manager"
+        }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(PanelViewListToggle, {
+          toggleLayerPanelListView: this._toggleLayerPanelListView,
+          layerPanelListViewMode: layerPanelListView
+        })), /*#__PURE__*/_react["default"].createElement(DatasetSection, {
+          datasets: datasets,
+          showDatasetTable: showDatasetTable,
+          updateTableColor: updateTableColor,
+          removeDataset: removeDataset,
+          showDeleteDataset: true,
+          showDatasetList: !isSortByDatasetMode,
+          showAddDataModal: showAddDataModal,
+          defaultDataset: defaultDataset
+        }), /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelDivider, null), /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(LayerHeader, null, /*#__PURE__*/_react["default"].createElement(PanelTitle, {
+          className: "layer-manager-title"
+        }, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+          id: panelMetadata.label
+        })), defaultDataset ?
+        /*#__PURE__*/
+        // TODO replace ignore
+        // @ts-ignore
+        _react["default"].createElement(AddLayerButton, {
+          datasets: datasets,
+          typeaheadPlaceholder: "Search datasets",
+          intl: intl,
+          onOptionSelected: this._addEmptyNewLayer
+        }) : null)), /*#__PURE__*/_react["default"].createElement(_styledComponents2.SidePanelSection, null, isSortByDatasetMode ? /*#__PURE__*/_react["default"].createElement(DatasetLayerGroup, {
+          datasets: datasets,
+          showDatasetTable: showDatasetTable,
+          layers: layers,
+          updateTableColor: updateTableColor,
+          removeDataset: removeDataset,
+          layerOrder: layerOrder,
+          layerClasses: this.props.layerClasses,
+          uiStateActions: uiStateActions,
+          visStateActions: visStateActions,
+          showDeleteDataset: true
+        }) :
+        /*#__PURE__*/
+        // TODO replace ignore
+        // @ts-ignore
+        _react["default"].createElement(LayerList, {
+          layers: layers,
+          datasets: datasets,
+          layerOrder: layerOrder,
+          uiStateActions: uiStateActions,
+          visStateActions: visStateActions,
+          layerClasses: this.props.layerClasses
+        })), /*#__PURE__*/_react["default"].createElement(LayerBlendingSelector, {
+          layerBlending: this.props.layerBlending,
+          updateLayerBlending: visStateActions.updateLayerBlending,
+          intl: intl
+        }));
+      }
+    }]);
+    return LayerManager;
+  }(_react.Component);
+
+  return (0, _reactIntl.injectIntl)(LayerManager);
+}
+
+var _default = LayerManagerFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/side-panel/layer-manager.tsx"],"names":["LayerHeader","styled","div","attrs","className","LayerBlendingSelector","React","memo","layerBlending","updateLayerBlending","intl","labeledLayerBlendings","Object","keys","LAYER_BLENDINGS","reduce","acc","current","formatMessage","id","label","onChange","blending","displayName","LayerManagerFactory","deps","LayerListFactory","DatasetLayerGroupFactory","PanelViewListToggleFactory","PanelTitleFactory","DatasetSectionFactory","AddLayerButtonFactory","LayerList","DatasetLayerGroup","PanelViewListToggle","PanelTitle","DatasetSection","AddLayerButton","LayerManager","dataset","visStateActions","props","addLayer","undefined","listView","uiStateActions","toggleLayerPanelListView","layers","datasets","layerOrder","showAddDataModal","updateTableColor","showDatasetTable","removeDataset","layerPanelListView","panelMetadata","defaultDataset","isSortByDatasetMode","_toggleLayerPanelListView","_addEmptyNewLayer","layerClasses","Component"],"mappings":"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","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, useCallback} from 'react';\n\nimport {injectIntl, WrappedComponentProps} from 'react-intl';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport styled from 'styled-components';\n\nimport LayerListFactory from './layer-panel/layer-list';\nimport DatasetLayerGroupFactory from './layer-panel/dataset-layer-group';\nimport PanelViewListToggleFactory from './layer-panel/panel-view-list-toggle';\nimport PanelTitleFactory from './panel-title';\nimport DatasetSectionFactory from './layer-panel/dataset-section';\nimport AddLayerButtonFactory from './layer-panel/add-layer-button';\n\nimport ItemSelector from '../common/item-selector/item-selector';\nimport {PanelLabel, SidePanelDivider, SidePanelSection} from '../common/styled-components';\n\nimport {LAYER_BLENDINGS} from '@kepler.gl/constants';\nimport {Layer, LayerClassesType} from '@kepler.gl/layers';\nimport {UIStateActions, VisStateActions, ActionHandler} from '@kepler.gl/actions';\nimport {SidePanelItem} from '../types';\nimport {LayerPanelListView} from '@kepler.gl/types';\nimport {Datasets} from '@kepler.gl/table';\n\ntype LayerBlendingSelectorProps = {\n  layerBlending: string;\n  updateLayerBlending: ActionHandler<typeof VisStateActions.updateLayerBlending>;\n} & WrappedComponentProps;\n\ntype LayerManagerProps = {\n  datasets: Datasets;\n  layers: Layer[];\n  layerOrder: number[];\n  layerClasses: LayerClassesType;\n  layerBlending: string;\n  uiStateActions: typeof UIStateActions;\n  visStateActions: typeof VisStateActions;\n  showAddDataModal: () => void;\n  removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  layerPanelListView: LayerPanelListView;\n  panelMetadata: SidePanelItem;\n} & WrappedComponentProps;\n\nconst LayerHeader = styled.div.attrs({\n  className: 'layer-manager-header'\n})`\n  display: flex;\n  justify-content: space-between;\n  align-items: flex-start;\n  margin-top: 16px;\n`;\n\nconst LayerBlendingSelector = React.memo(\n  ({layerBlending, updateLayerBlending, intl}: LayerBlendingSelectorProps) => {\n    const labeledLayerBlendings = Object.keys(LAYER_BLENDINGS).reduce(\n      (acc, current) => ({\n        ...acc,\n        [intl.formatMessage({id: LAYER_BLENDINGS[current].label})]: current\n      }),\n      {}\n    );\n\n    const onChange = useCallback(blending => updateLayerBlending(labeledLayerBlendings[blending]), [\n      updateLayerBlending,\n      labeledLayerBlendings\n    ]);\n\n    return (\n      <SidePanelSection>\n        <PanelLabel>\n          <FormattedMessage id=\"layerBlending.title\" />\n        </PanelLabel>\n        <ItemSelector\n          selectedItems={intl.formatMessage({id: LAYER_BLENDINGS[layerBlending].label})}\n          options={Object.keys(labeledLayerBlendings)}\n          multiSelect={false}\n          searchable={false}\n          onChange={onChange}\n        />\n      </SidePanelSection>\n    );\n  }\n);\nLayerBlendingSelector.displayName = 'LayerBlendingSelector';\n\nLayerManagerFactory.deps = [\n  LayerListFactory,\n  DatasetLayerGroupFactory,\n  PanelViewListToggleFactory,\n  PanelTitleFactory,\n  DatasetSectionFactory,\n  AddLayerButtonFactory\n];\n\nfunction LayerManagerFactory(\n  LayerList: ReturnType<typeof LayerListFactory>,\n  DatasetLayerGroup: ReturnType<typeof DatasetLayerGroupFactory>,\n  PanelViewListToggle: ReturnType<typeof PanelViewListToggleFactory>,\n  PanelTitle: ReturnType<typeof PanelTitleFactory>,\n  DatasetSection: ReturnType<typeof DatasetSectionFactory>,\n  AddLayerButton: ReturnType<typeof AddLayerButtonFactory>\n) {\n  class LayerManager extends Component<LayerManagerProps> {\n    _addEmptyNewLayer = (dataset: string) => {\n      const {visStateActions} = this.props;\n      visStateActions.addLayer(undefined, dataset);\n    };\n\n    _toggleLayerPanelListView = (listView: string) => {\n      const {uiStateActions} = this.props;\n      uiStateActions.toggleLayerPanelListView(listView);\n    };\n\n    render() {\n      const {\n        layers,\n        datasets,\n        intl,\n        layerOrder,\n        showAddDataModal,\n        updateTableColor,\n        showDatasetTable,\n        removeDataset,\n        uiStateActions,\n        visStateActions,\n        layerPanelListView,\n        panelMetadata\n      } = this.props;\n\n      const defaultDataset = Object.keys(datasets)[0];\n      const isSortByDatasetMode = layerPanelListView === 'sortByDataset';\n\n      return (\n        <div className=\"layer-manager\">\n          <SidePanelSection>\n            <PanelViewListToggle\n              toggleLayerPanelListView={this._toggleLayerPanelListView}\n              layerPanelListViewMode={layerPanelListView}\n            />\n          </SidePanelSection>\n          <DatasetSection\n            datasets={datasets}\n            showDatasetTable={showDatasetTable}\n            updateTableColor={updateTableColor}\n            removeDataset={removeDataset}\n            showDeleteDataset\n            showDatasetList={!isSortByDatasetMode}\n            showAddDataModal={showAddDataModal}\n            defaultDataset={defaultDataset}\n          />\n          <SidePanelDivider />\n          <SidePanelSection>\n            <LayerHeader>\n              <PanelTitle className=\"layer-manager-title\">\n                <FormattedMessage id={panelMetadata.label} />\n              </PanelTitle>\n              {defaultDataset ? (\n                // TODO replace ignore\n                // @ts-ignore\n                <AddLayerButton\n                  datasets={datasets}\n                  typeaheadPlaceholder=\"Search datasets\"\n                  intl={intl}\n                  onOptionSelected={this._addEmptyNewLayer}\n                />\n              ) : null}\n            </LayerHeader>\n          </SidePanelSection>\n          <SidePanelSection>\n            {isSortByDatasetMode ? (\n              <DatasetLayerGroup\n                datasets={datasets}\n                showDatasetTable={showDatasetTable}\n                layers={layers}\n                updateTableColor={updateTableColor}\n                removeDataset={removeDataset}\n                layerOrder={layerOrder}\n                layerClasses={this.props.layerClasses}\n                uiStateActions={uiStateActions}\n                visStateActions={visStateActions}\n                showDeleteDataset\n              />\n            ) : (\n              // TODO replace ignore\n              // @ts-ignore\n              <LayerList\n                layers={layers}\n                datasets={datasets}\n                layerOrder={layerOrder}\n                uiStateActions={uiStateActions}\n                visStateActions={visStateActions}\n                layerClasses={this.props.layerClasses}\n              />\n            )}\n          </SidePanelSection>\n          <LayerBlendingSelector\n            layerBlending={this.props.layerBlending}\n            updateLayerBlending={visStateActions.updateLayerBlending}\n            intl={intl}\n          />\n        </div>\n      );\n    }\n  }\n  return injectIntl(LayerManager);\n}\n\nexport default LayerManagerFactory;\n"]}

package/dist/side-panel/layer-panel/add-layer-button.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl';
+import { Datasets } from '@kepler.gl/table';
+declare type AddLayerButtonProps = {
+    datasets: Datasets;
+    onOptionSelected: (opt: string) => void;
+    typeaheadPlaceholder?: string;
+} & WrappedComponentProps;
+declare function AddLayerButtonFactory(): React.FC<AddLayerButtonProps>;
+export default AddLayerButtonFactory;

package/dist/side-panel/layer-panel/add-layer-button.js

@@ -0,0 +1,176 @@
+// 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["default"] = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _react2 = _interopRequireDefault(require("@tippyjs/react"));
+
+var _icons = require("../../common/icons");
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _ = require("../..");
+
+var _typeahead = _interopRequireDefault(require("../../common/item-selector/typeahead"));
+
+var _accessor = _interopRequireDefault(require("../../common/item-selector/accessor"));
+
+var _templateObject, _templateObject2, _templateObject3;
+
+var DropdownContainer = _styledComponents["default"].div.attrs({
+  className: 'add-layer-menu-dropdown'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  .list-selector {\n    border-top: 1px solid ", ";\n    width: 100%;\n    /* disable scrolling, currently set to 280px internally */\n    max-height: unset;\n  }\n\n  .list__item > div {\n    display: flex;\n    flex-direction: row;\n    justify-content: flex-start;\n    line-height: 18px;\n    padding: 0;\n\n    svg {\n      margin-right: 10px;\n    }\n  }\n"])), function (props) {
+  return props.theme.secondaryInputBorderColor;
+});
+
+var AddLayerMenu = _styledComponents["default"].div.attrs({
+  className: 'add-layer-menu'
+})(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex-direction: column;\n  min-width: 240px;\n  max-width: 240px;\n  position: absolute;\n  top: 100%;\n  left: -53px;\n  z-index: 5;\n"])));
+
+var ListItemWrapper = _styledComponents["default"].div.attrs({
+  className: 'add-layer-menu-list-item-wrapper'
+})(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  color: ", ";\n  font-size: 11px;\n  letter-spacing: 0.2px;\n  overflow: auto;\n\n  .dataset-color {\n    flex-shrink: 0;\n    margin-top: 3px;\n  }\n\n  .dataset-name {\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n"])), function (props) {
+  return props.theme.textColor;
+});
+
+var TYPEAHEAD_CLASS = 'typeahead';
+var TYPEAHEAD_INPUT_CLASS = 'typeahead__input';
+
+function AddLayerButtonFactory() {
+  var ListItem = function ListItem(_ref) {
+    var value = _ref.value;
+    return /*#__PURE__*/_react["default"].createElement(ListItemWrapper, null, /*#__PURE__*/_react["default"].createElement(_.DatasetSquare, {
+      className: "dataset-color",
+      backgroundColor: value.color
+    }), /*#__PURE__*/_react["default"].createElement("div", {
+      className: "dataset-name",
+      title: value.label
+    }, value.label));
+  };
+
+  var AddLayerButton = function AddLayerButton(props) {
+    var datasets = props.datasets,
+        onOptionSelected = props.onOptionSelected,
+        typeaheadPlaceholder = props.typeaheadPlaceholder,
+        intl = props.intl;
+
+    var _useState = (0, _react.useState)(false),
+        _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+        showAddLayerDropdown = _useState2[0],
+        setShowAddLayerDropdown = _useState2[1];
+
+    var toggleAddLayerDropdown = (0, _react.useCallback)(function () {
+      setShowAddLayerDropdown(!showAddLayerDropdown);
+    }, [showAddLayerDropdown, setShowAddLayerDropdown]);
+
+    var _onBlur = (0, _react.useCallback)(function () {
+      setShowAddLayerDropdown(false);
+    }, []);
+
+    var toggleSelectedOption = (0, _react.useCallback)(function (option) {
+      onOptionSelected(option.value);
+
+      _onBlur();
+    }, [onOptionSelected, _onBlur]);
+    var onButtonBlur = (0, _react.useCallback)(function (event) {
+      if ([TYPEAHEAD_CLASS, TYPEAHEAD_INPUT_CLASS].every(function (cls) {
+        var _event$relatedTarget;
+
+        return !(event !== null && event !== void 0 && (_event$relatedTarget = event.relatedTarget) !== null && _event$relatedTarget !== void 0 && _event$relatedTarget.classList.contains(cls));
+      })) {
+        _onBlur();
+      }
+    }, [_onBlur]);
+    var onSearchBlur = (0, _react.useCallback)(function () {
+      _onBlur();
+    }, [_onBlur]);
+    var options = (0, _react.useMemo)(function () {
+      return Object.values(datasets).map(function (ds) {
+        return {
+          label: ds.label,
+          value: ds.id,
+          color: ds.color
+        };
+      });
+    }, [datasets]);
+    return /*#__PURE__*/_react["default"].createElement(_react2["default"], {
+      visible: showAddLayerDropdown,
+      arrow: false,
+      interactive: true,
+      placement: "bottom",
+      appendTo: "parent",
+      duration: 0,
+      content: /*#__PURE__*/_react["default"].createElement(AddLayerMenu, null, /*#__PURE__*/_react["default"].createElement(DropdownContainer, null, /*#__PURE__*/_react["default"].createElement(_typeahead["default"], {
+        onBlur: onSearchBlur,
+        className: TYPEAHEAD_CLASS,
+        customClasses: {
+          results: 'list-selector',
+          input: TYPEAHEAD_INPUT_CLASS,
+          listItem: 'list__item'
+        },
+        placeholder: typeaheadPlaceholder || intl ? intl.formatMessage({
+          id: 'placeholder.search'
+        }) : 'Search',
+        selectedItems: null,
+        options: options,
+        displayOption: _accessor["default"].generateOptionToStringFor('label'),
+        filterOption: 'label',
+        searchable: true,
+        onOptionSelected: toggleSelectedOption,
+        customListItemComponent: ListItem
+      })))
+    }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.Button, {
+      tabIndex: -1,
+      onBlur: onButtonBlur,
+      className: "add-layer-button",
+      width: "105px",
+      onClick: toggleAddLayerDropdown
+    }, /*#__PURE__*/_react["default"].createElement(_icons.Add, {
+      height: "12px"
+    }), /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'layerManager.addLayer'
+    })));
+  };
+
+  return AddLayerButton;
+}
+
+var _default = AddLayerButtonFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/layer-panel/add-layer-button.tsx"],"names":["DropdownContainer","styled","div","attrs","className","props","theme","secondaryInputBorderColor","AddLayerMenu","ListItemWrapper","textColor","TYPEAHEAD_CLASS","TYPEAHEAD_INPUT_CLASS","AddLayerButtonFactory","ListItem","value","color","label","AddLayerButton","datasets","onOptionSelected","typeaheadPlaceholder","intl","showAddLayerDropdown","setShowAddLayerDropdown","toggleAddLayerDropdown","_onBlur","toggleSelectedOption","option","onButtonBlur","event","every","cls","relatedTarget","classList","contains","onSearchBlur","options","Object","values","map","ds","id","results","input","listItem","formatMessage","Accessor","generateOptionToStringFor"],"mappings":";;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAUA,IAAMA,iBAAiB,GAAGC,6BAAOC,GAAP,CAAWC,KAAX,CAAiB;AACzCC,EAAAA,SAAS,EAAE;AAD8B,CAAjB,CAAH,mcAIK,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYC,yBAAhB;AAAA,CAJV,CAAvB;;AAuBA,IAAMC,YAAY,GAAGP,6BAAOC,GAAP,CAAWC,KAAX,CAAiB;AACpCC,EAAAA,SAAS,EAAE;AADyB,CAAjB,CAAH,qPAAlB;;AAaA,IAAMK,eAAe,GAAGR,6BAAOC,GAAP,CAAWC,KAAX,CAAiB;AACvCC,EAAAA,SAAS,EAAE;AAD4B,CAAjB,CAAH,6WAIV,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYI,SAAhB;AAAA,CAJK,CAArB;;AAqBA,IAAMC,eAAe,GAAG,WAAxB;AACA,IAAMC,qBAAqB,GAAG,kBAA9B;;AAEA,SAASC,qBAAT,GAAiC;AAC/B,MAAMC,QAAQ,GAAG,SAAXA,QAAW;AAAA,QAAEC,KAAF,QAAEA,KAAF;AAAA,wBACf,gCAAC,eAAD,qBACE,gCAAC,eAAD;AAAe,MAAA,SAAS,EAAC,eAAzB;AAAyC,MAAA,eAAe,EAAEA,KAAK,CAACC;AAAhE,MADF,eAEE;AAAK,MAAA,SAAS,EAAC,cAAf;AAA8B,MAAA,KAAK,EAAED,KAAK,CAACE;AAA3C,OACGF,KAAK,CAACE,KADT,CAFF,CADe;AAAA,GAAjB;;AASA,MAAMC,cAA6C,GAAG,SAAhDA,cAAgD,CAAAb,KAAK,EAAI;AAAA,QACtDc,QADsD,GACId,KADJ,CACtDc,QADsD;AAAA,QAC5CC,gBAD4C,GACIf,KADJ,CAC5Ce,gBAD4C;AAAA,QAC1BC,oBAD0B,GACIhB,KADJ,CAC1BgB,oBAD0B;AAAA,QACJC,IADI,GACIjB,KADJ,CACJiB,IADI;;AAAA,oBAEL,qBAAS,KAAT,CAFK;AAAA;AAAA,QAEtDC,oBAFsD;AAAA,QAEhCC,uBAFgC;;AAI7D,QAAMC,sBAAsB,GAAG,wBAAY,YAAM;AAC/CD,MAAAA,uBAAuB,CAAC,CAACD,oBAAF,CAAvB;AACD,KAF8B,EAE5B,CAACA,oBAAD,EAAuBC,uBAAvB,CAF4B,CAA/B;;AAIA,QAAME,OAAO,GAAG,wBAAY,YAAM;AAChCF,MAAAA,uBAAuB,CAAC,KAAD,CAAvB;AACD,KAFe,EAEb,EAFa,CAAhB;;AAIA,QAAMG,oBAAoB,GAAG,wBAC3B,UAACC,MAAD,EAA6D;AAC3DR,MAAAA,gBAAgB,CAACQ,MAAM,CAACb,KAAR,CAAhB;;AACAW,MAAAA,OAAO;AACR,KAJ0B,EAK3B,CAACN,gBAAD,EAAmBM,OAAnB,CAL2B,CAA7B;AAQA,QAAMG,YAAY,GAAG,wBACnB,UAAAC,KAAK,EAAI;AACP,UACE,CAACnB,eAAD,EAAkBC,qBAAlB,EAAyCmB,KAAzC,CACE,UAAAC,GAAG;AAAA;;AAAA,eAAI,EAACF,KAAD,aAACA,KAAD,uCAACA,KAAK,CAAEG,aAAR,iDAAC,qBAAsBC,SAAtB,CAAgCC,QAAhC,CAAyCH,GAAzC,CAAD,CAAJ;AAAA,OADL,CADF,EAIE;AACAN,QAAAA,OAAO;AACR;AACF,KATkB,EAUnB,CAACA,OAAD,CAVmB,CAArB;AAaA,QAAMU,YAAY,GAAG,wBAAY,YAAM;AACrCV,MAAAA,OAAO;AACR,KAFoB,EAElB,CAACA,OAAD,CAFkB,CAArB;AAIA,QAAMW,OAAO,GAAG,oBAAQ,YAAM;AAC5B,aAAOC,MAAM,CAACC,MAAP,CAAcpB,QAAd,EAAwBqB,GAAxB,CAA4B,UAAAC,EAAE;AAAA,eAAK;AACxCxB,UAAAA,KAAK,EAAEwB,EAAE,CAACxB,KAD8B;AAExCF,UAAAA,KAAK,EAAE0B,EAAE,CAACC,EAF8B;AAGxC1B,UAAAA,KAAK,EAAEyB,EAAE,CAACzB;AAH8B,SAAL;AAAA,OAA9B,CAAP;AAKD,KANe,EAMb,CAACG,QAAD,CANa,CAAhB;AAQA,wBACE,gCAAC,kBAAD;AACE,MAAA,OAAO,EAAEI,oBADX;AAEE,MAAA,KAAK,EAAE,KAFT;AAGE,MAAA,WAAW,MAHb;AAIE,MAAA,SAAS,EAAC,QAJZ;AAKE,MAAA,QAAQ,EAAC,QALX;AAME,MAAA,QAAQ,EAAE,CANZ;AAOE,MAAA,OAAO,eACL,gCAAC,YAAD,qBACE,gCAAC,iBAAD,qBACE,gCAAC,qBAAD;AACE,QAAA,MAAM,EAAEa,YADV;AAEE,QAAA,SAAS,EAAEzB,eAFb;AAGE,QAAA,aAAa,EAAE;AACbgC,UAAAA,OAAO,EAAE,eADI;AAEbC,UAAAA,KAAK,EAAEhC,qBAFM;AAGbiC,UAAAA,QAAQ,EAAE;AAHG,SAHjB;AAQE,QAAA,WAAW,EACTxB,oBAAoB,IAAIC,IAAxB,GACIA,IAAI,CAACwB,aAAL,CAAmB;AAACJ,UAAAA,EAAE,EAAE;AAAL,SAAnB,CADJ,GAEI,QAXR;AAaE,QAAA,aAAa,EAAE,IAbjB;AAcE,QAAA,OAAO,EAAEL,OAdX;AAeE,QAAA,aAAa,EAAEU,qBAASC,yBAAT,CAAmC,OAAnC,CAfjB;AAgBE,QAAA,YAAY,EAAE,OAhBhB;AAiBE,QAAA,UAAU,MAjBZ;AAkBE,QAAA,gBAAgB,EAAErB,oBAlBpB;AAmBE,QAAA,uBAAuB,EAAEb;AAnB3B,QADF,CADF;AARJ,oBAmCE,gCAAC,yBAAD;AACE,MAAA,QAAQ,EAAE,CAAC,CADb;AAEE,MAAA,MAAM,EAAEe,YAFV;AAGE,MAAA,SAAS,EAAC,kBAHZ;AAIE,MAAA,KAAK,EAAC,OAJR;AAKE,MAAA,OAAO,EAAEJ;AALX,oBAOE,gCAAC,UAAD;AAAK,MAAA,MAAM,EAAC;AAAZ,MAPF,eAQE,gCAAC,8BAAD;AAAkB,MAAA,EAAE,EAAE;AAAtB,MARF,CAnCF,CADF;AAgDD,GA7FD;;AA+FA,SAAOP,cAAP;AACD;;eAEcL,qB","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, {useCallback, useMemo, useState} from 'react';\nimport styled from 'styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {WrappedComponentProps} from 'react-intl';\n\nimport Tippy from '@tippyjs/react';\nimport {Add} from '../../common/icons';\nimport {Button} from '../../common/styled-components';\nimport {DatasetSquare} from '../..';\nimport Typeahead from '../../common/item-selector/typeahead';\nimport Accessor from '../../common/item-selector/accessor';\nimport {Datasets} from '@kepler.gl/table';\nimport {RGBColor} from '@kepler.gl/types';\n\ntype AddLayerButtonProps = {\n  datasets: Datasets;\n  onOptionSelected: (opt: string) => void;\n  typeaheadPlaceholder?: string;\n} & WrappedComponentProps;\n\nconst DropdownContainer = styled.div.attrs({\n  className: 'add-layer-menu-dropdown'\n})`\n  .list-selector {\n    border-top: 1px solid ${props => props.theme.secondaryInputBorderColor};\n    width: 100%;\n    /* disable scrolling, currently set to 280px internally */\n    max-height: unset;\n  }\n\n  .list__item > div {\n    display: flex;\n    flex-direction: row;\n    justify-content: flex-start;\n    line-height: 18px;\n    padding: 0;\n\n    svg {\n      margin-right: 10px;\n    }\n  }\n`;\n\nconst AddLayerMenu = styled.div.attrs({\n  className: 'add-layer-menu'\n})`\n  display: flex;\n  flex-direction: column;\n  min-width: 240px;\n  max-width: 240px;\n  position: absolute;\n  top: 100%;\n  left: -53px;\n  z-index: 5;\n`;\n\nconst ListItemWrapper = styled.div.attrs({\n  className: 'add-layer-menu-list-item-wrapper'\n})`\n  display: flex;\n  color: ${props => props.theme.textColor};\n  font-size: 11px;\n  letter-spacing: 0.2px;\n  overflow: auto;\n\n  .dataset-color {\n    flex-shrink: 0;\n    margin-top: 3px;\n  }\n\n  .dataset-name {\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n`;\n\nconst TYPEAHEAD_CLASS = 'typeahead';\nconst TYPEAHEAD_INPUT_CLASS = 'typeahead__input';\n\nfunction AddLayerButtonFactory() {\n  const ListItem = ({value}) => (\n    <ListItemWrapper>\n      <DatasetSquare className=\"dataset-color\" backgroundColor={value.color} />\n      <div className=\"dataset-name\" title={value.label}>\n        {value.label}\n      </div>\n    </ListItemWrapper>\n  );\n\n  const AddLayerButton: React.FC<AddLayerButtonProps> = props => {\n    const {datasets, onOptionSelected, typeaheadPlaceholder, intl} = props;\n    const [showAddLayerDropdown, setShowAddLayerDropdown] = useState(false);\n\n    const toggleAddLayerDropdown = useCallback(() => {\n      setShowAddLayerDropdown(!showAddLayerDropdown);\n    }, [showAddLayerDropdown, setShowAddLayerDropdown]);\n\n    const _onBlur = useCallback(() => {\n      setShowAddLayerDropdown(false);\n    }, []);\n\n    const toggleSelectedOption = useCallback(\n      (option: {label: string; value: string; color: RGBColor}) => {\n        onOptionSelected(option.value);\n        _onBlur();\n      },\n      [onOptionSelected, _onBlur]\n    );\n\n    const onButtonBlur = useCallback(\n      event => {\n        if (\n          [TYPEAHEAD_CLASS, TYPEAHEAD_INPUT_CLASS].every(\n            cls => !event?.relatedTarget?.classList.contains(cls)\n          )\n        ) {\n          _onBlur();\n        }\n      },\n      [_onBlur]\n    );\n\n    const onSearchBlur = useCallback(() => {\n      _onBlur();\n    }, [_onBlur]);\n\n    const options = useMemo(() => {\n      return Object.values(datasets).map(ds => ({\n        label: ds.label,\n        value: ds.id,\n        color: ds.color\n      }));\n    }, [datasets]);\n\n    return (\n      <Tippy\n        visible={showAddLayerDropdown}\n        arrow={false}\n        interactive\n        placement=\"bottom\"\n        appendTo=\"parent\"\n        duration={0}\n        content={\n          <AddLayerMenu>\n            <DropdownContainer>\n              <Typeahead\n                onBlur={onSearchBlur}\n                className={TYPEAHEAD_CLASS}\n                customClasses={{\n                  results: 'list-selector',\n                  input: TYPEAHEAD_INPUT_CLASS,\n                  listItem: 'list__item'\n                }}\n                placeholder={\n                  typeaheadPlaceholder || intl\n                    ? intl.formatMessage({id: 'placeholder.search'})\n                    : 'Search'\n                }\n                selectedItems={null}\n                options={options}\n                displayOption={Accessor.generateOptionToStringFor('label')}\n                filterOption={'label'}\n                searchable\n                onOptionSelected={toggleSelectedOption}\n                customListItemComponent={ListItem}\n              />\n            </DropdownContainer>\n          </AddLayerMenu>\n        }\n      >\n        <Button\n          tabIndex={-1}\n          onBlur={onButtonBlur}\n          className=\"add-layer-button\"\n          width=\"105px\"\n          onClick={toggleAddLayerDropdown}\n        >\n          <Add height=\"12px\" />\n          <FormattedMessage id={'layerManager.addLayer'} />\n        </Button>\n      </Tippy>\n    );\n  };\n\n  return AddLayerButton;\n}\n\nexport default AddLayerButtonFactory;\n"]}

package/dist/side-panel/layer-panel/color-palette.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { HexColor, RGBColor } from '@kepler.gl/types';
+declare type ColorPaletteProps = {
+    colors: RGBColor | HexColor[];
+    height?: number;
+    className?: string;
+    isSelected?: boolean;
+    isReversed?: boolean;
+};
+declare const ColorPalette: React.FC<ColorPaletteProps>;
+export default ColorPalette;

package/dist/side-panel/layer-panel/color-palette.js

@@ -0,0 +1,91 @@
+// 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 _classnames = _interopRequireDefault(require("classnames"));
+
+var _templateObject, _templateObject2, _templateObject3;
+
+var defaultProps = {
+  height: 10,
+  colors: [],
+  className: '',
+  isSelected: false,
+  isReversed: false
+};
+
+var PaletteWrapper = _styledComponents["default"].div.attrs({
+  className: 'color-range-palette__inner'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  border-radius: 2px;\n  display: flex;\n  flex-direction: row;\n  flex-grow: 1;\n  justify-content: space-between;\n  overflow: hidden;\n"])));
+
+var PaletteContainer = _styledComponents["default"].div.attrs(function (props) {
+  return {
+    className: (0, _classnames["default"])('color-range-palette', props.className)
+  };
+})(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex-grow: 1;\n  border-width: 1px;\n  border-style: solid;\n  border-color: ", ";\n  padding: 4px;\n  border-radius: 4px;\n"])), function (props) {
+  return props.isSelected ? '#FFFFFF' : 'transparent';
+});
+
+var StyledColorBlock = _styledComponents["default"].div.attrs({
+  className: 'color-range-palette__block'
+})(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  flex-grow: 1;\n"])));
+
+var ColorPalette = function ColorPalette(_ref) {
+  var colors = _ref.colors,
+      height = _ref.height,
+      className = _ref.className,
+      isSelected = _ref.isSelected,
+      isReversed = _ref.isReversed;
+  return /*#__PURE__*/_react["default"].createElement(PaletteContainer, {
+    className: className,
+    isSelected: isSelected
+  }, /*#__PURE__*/_react["default"].createElement(PaletteWrapper, {
+    style: {
+      height: height,
+      transform: "scale(".concat(isReversed ? -1 : 1, ", 1)")
+    }
+  }, colors.map(function (color, index) {
+    return /*#__PURE__*/_react["default"].createElement(StyledColorBlock, {
+      key: "".concat(color, "-").concat(index),
+      style: {
+        backgroundColor: String(color)
+      }
+    });
+  })));
+};
+
+ColorPalette.defaultProps = defaultProps;
+var _default = ColorPalette;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/color-range-selector.d.ts

@@ -0,0 +1,47 @@
+import React, { Component, MouseEvent } from 'react';
+import { ColorRange } from '@kepler.gl/constants';
+import { NestedPartial, ColorUI } from '@kepler.gl/types';
+declare type ColorRangeSelectorProps = {
+    colorPaletteUI: ColorUI;
+    selectedColorRange: ColorRange;
+    onSelectColorRange: (p: ColorRange, e: MouseEvent) => void;
+    setColorPaletteUI: (newConfig: NestedPartial<ColorUI>) => void;
+};
+declare type PaletteConfigProps = {
+    label: string;
+    value: string | number | boolean;
+    config: {
+        type: string;
+        options: (string | number | boolean)[];
+    };
+    onChange: (v: string | number | boolean | object | null) => void;
+};
+declare type ColorPaletteGroupProps = {
+    reversed?: boolean;
+    selected: ColorRange;
+    colorRanges: ColorRange[];
+    onSelect: (p: ColorRange, e: MouseEvent) => void;
+};
+export declare const ALL_TYPES: string[];
+export declare const ALL_STEPS: number[];
+export default class ColorRangeSelector extends Component<ColorRangeSelectorProps> {
+    static defaultProps: {
+        onSelectColorRange: () => void;
+        setColorPaletteUI: () => void;
+    };
+    configTypeSelector: (props: ColorRangeSelectorProps) => string;
+    configStepSelector: (props: ColorRangeSelectorProps) => number;
+    filteredColorRange: import("reselect").OutputSelector<ColorRangeSelectorProps, ColorRange[], (res1: string, res2: number) => ColorRange[]>;
+    _updateConfig: ({ key, value }: {
+        key: string;
+        value: string | number | boolean | object | null;
+    }) => void;
+    _onSetCustomPalette: (config: NestedPartial<ColorRange>) => void;
+    _setColorRangeConfig: (newConfig: Record<string, string | number | boolean | object | null>) => void;
+    _onCustomPaletteCancel: () => void;
+    _onToggleSketcher: (val: boolean | number) => void;
+    render(): JSX.Element;
+}
+export declare const PaletteConfig: React.FC<PaletteConfigProps>;
+export declare const ColorPaletteGroup: React.FC<ColorPaletteGroupProps>;
+export {};