@kepler.gl/components 3.0.0-alpha.0

package/dist/side-panel/layer-panel/custom-picker.js

@@ -0,0 +1,136 @@
+// 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 _styledComponents = _interopRequireWildcard(require("styled-components"));
+
+var _reactColor = require("react-color");
+
+var _reactOnclickoutside = _interopRequireDefault(require("react-onclickoutside"));
+
+var _reselect = require("reselect");
+
+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; } }
+
+var StyledPicker = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  .sketch-picker {\n    span {\n      color: ", " !important;\n      font-family: ", ";\n    }\n    input {\n      text-align: center;\n      font-family: ", ";\n      color: ", " !important;\n      border-color: ", " !important;\n      box-shadow: none !important;\n      background-color: ", " !important;\n    }\n  }\n"])), function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.inputColor;
+}, function (props) {
+  return props.theme.secondaryInputBgd;
+}, function (props) {
+  return props.theme.inputBgdHover;
+});
+
+var PRESET_COLORS = [];
+
+var CustomPicker = /*#__PURE__*/function (_Component) {
+  (0, _inherits2["default"])(CustomPicker, _Component);
+
+  var _super = _createSuper(CustomPicker);
+
+  function CustomPicker() {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, CustomPicker);
+
+    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), "themeSelector", function (props) {
+      return props.theme;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "pickerStyleSelector", (0, _reselect.createSelector)(_this.themeSelector, function (theme) {
+      return {
+        picker: {
+          width: '200px',
+          padding: '10px 10px 8px',
+          boxSizing: 'initial',
+          background: theme.panelBackground
+        }
+      };
+    }));
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleClickOutside", function (e) {
+      _this.props.onSwatchClose();
+    });
+    return _this;
+  }
+
+  (0, _createClass2["default"])(CustomPicker, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          color = _this$props.color,
+          onChange = _this$props.onChange;
+      var pickerStyle = this.pickerStyleSelector(this.props);
+      return /*#__PURE__*/_react["default"].createElement(StyledPicker, null, /*#__PURE__*/_react["default"].createElement(_reactColor.SketchPicker, {
+        color: color,
+        onChange: onChange,
+        presetColors: PRESET_COLORS,
+        styles: pickerStyle,
+        disableAlpha: true
+      }));
+    }
+  }]);
+  return CustomPicker;
+}(_react.Component);
+
+var _default = (0, _styledComponents.withTheme)((0, _reactOnclickoutside["default"])(CustomPicker));
+
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/dataset-layer-group.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import DatasetLayerSectionFactory from './dataset-layer-section';
+import { Layer, LayerClassesType } from '@kepler.gl/layers';
+import { UIStateActions, VisStateActions, ActionHandler } from '@kepler.gl/actions';
+import { Datasets } from '@kepler.gl/table';
+declare type DatasetLayerGroupProps = {
+    datasets: Datasets;
+    layers: Layer[];
+    layerOrder: number[];
+    layerClasses: LayerClassesType;
+    showDeleteDataset: boolean;
+    removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    uiStateActions: typeof UIStateActions;
+    visStateActions: typeof VisStateActions;
+};
+declare function DatasetLayerGroupFactory(DatasetLayerSection: ReturnType<typeof DatasetLayerSectionFactory>): React.FC<DatasetLayerGroupProps>;
+declare namespace DatasetLayerGroupFactory {
+    var deps: (typeof DatasetLayerSectionFactory)[];
+}
+export default DatasetLayerGroupFactory;

package/dist/side-panel/layer-panel/dataset-layer-group.js

@@ -0,0 +1,86 @@
+// 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 _react = _interopRequireWildcard(require("react"));
+
+var _datasetLayerSection = _interopRequireDefault(require("./dataset-layer-section"));DatasetLayerGroupFactory.deps = [_datasetLayerSection["default"]];
+
+function DatasetLayerGroupFactory(DatasetLayerSection) {
+  var DatasetLayerGroup = function DatasetLayerGroup(props) {
+    var datasets = props.datasets,
+        showDatasetTable = props.showDatasetTable,
+        layers = props.layers,
+        updateTableColor = props.updateTableColor,
+        showDeleteDataset = props.showDeleteDataset,
+        removeDataset = props.removeDataset,
+        layerOrder = props.layerOrder,
+        layerClasses = props.layerClasses,
+        uiStateActions = props.uiStateActions,
+        visStateActions = props.visStateActions;
+    var datasetLayerSectionData = (0, _react.useMemo)(function () {
+      return Object.values(datasets).map(function (dataset) {
+        // Global layer order will contain the correct order of layers
+        // We just empty the positions in layers array (for each dataset)
+        // where the layer doesn't belong to a dataset and set it to null
+        var datasetLayers = layers.map(function (layer) {
+          return layer.config.dataId === dataset.id ? layer : null;
+        }).filter(function (layer) {
+          return Boolean(layer);
+        });
+        return {
+          dataset: dataset,
+          datasetLayers: datasetLayers
+        };
+      });
+    }, [datasets, layers]);
+    return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, datasetLayerSectionData.map(function (dlsData) {
+      return /*#__PURE__*/_react["default"].createElement(DatasetLayerSection, {
+        key: dlsData.dataset.id,
+        dataset: dlsData.dataset,
+        layers: dlsData.datasetLayers,
+        showDatasetTable: showDatasetTable,
+        updateTableColor: updateTableColor,
+        showDeleteDataset: showDeleteDataset,
+        removeDataset: removeDataset,
+        layerOrder: layerOrder,
+        layerClasses: layerClasses,
+        uiStateActions: uiStateActions,
+        visStateActions: visStateActions
+      });
+    }));
+  };
+
+  return DatasetLayerGroup;
+}
+
+var _default = DatasetLayerGroupFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/dataset-layer-section.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import LayerListFactory from './layer-list';
+import { Layer, LayerClassesType } from '@kepler.gl/layers';
+import { UIStateActions, ActionHandler, VisStateActions } from '@kepler.gl/actions';
+import { KeplerTable } from '@kepler.gl/table';
+declare type DatasetLayerSectionProps = {
+    dataset: KeplerTable;
+    layers: Layer[];
+    layerOrder: number[];
+    layerClasses: LayerClassesType;
+    showDeleteDataset: boolean;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;
+    uiStateActions: typeof UIStateActions;
+    visStateActions: typeof VisStateActions;
+};
+declare function DatasetLayerSectionFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, LayerList: ReturnType<typeof LayerListFactory>): React.FC<DatasetLayerSectionProps>;
+declare namespace DatasetLayerSectionFactory {
+    var deps: (typeof LayerListFactory | typeof SourceDataCatalogFactory)[];
+}
+export default DatasetLayerSectionFactory;

package/dist/side-panel/layer-panel/dataset-layer-section.js

@@ -0,0 +1,89 @@
+// 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 _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 _sourceDataCatalog = _interopRequireDefault(require("../common/source-data-catalog"));
+
+var _layerList = _interopRequireDefault(require("./layer-list"));
+
+var _templateObject;
+
+var DatasetLayerSectionWrapper = _styledComponents["default"].div.attrs({
+  className: 'dataset-layer-section'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  margin-bottom: 16px;\n"])));
+
+DatasetLayerSectionFactory.deps = [_sourceDataCatalog["default"], _layerList["default"]];
+
+function DatasetLayerSectionFactory(SourceDataCatalog, LayerList) {
+  var DatasetLayerSection = function DatasetLayerSection(props) {
+    var dataset = props.dataset,
+        showDatasetTable = props.showDatasetTable,
+        layers = props.layers,
+        updateTableColor = props.updateTableColor,
+        showDeleteDataset = props.showDeleteDataset,
+        removeDataset = props.removeDataset,
+        layerOrder = props.layerOrder,
+        layerClasses = props.layerClasses,
+        uiStateActions = props.uiStateActions,
+        visStateActions = props.visStateActions;
+    var datasets = (0, _react.useMemo)(function () {
+      return (0, _defineProperty2["default"])({}, dataset.id, dataset);
+    }, [dataset]);
+    return /*#__PURE__*/_react["default"].createElement(DatasetLayerSectionWrapper, null, /*#__PURE__*/_react["default"].createElement(SourceDataCatalog, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: showDeleteDataset
+    }), /*#__PURE__*/_react["default"].createElement(LayerList, {
+      datasets: datasets,
+      layerOrder: layerOrder,
+      layers: layers,
+      layerClasses: layerClasses,
+      uiStateActions: uiStateActions,
+      visStateActions: visStateActions,
+      isSortable: false
+    }));
+  };
+
+  return DatasetLayerSection;
+}
+
+var _default = DatasetLayerSectionFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/dataset-section.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import { UIStateActions, VisStateActions, ActionHandler } from '@kepler.gl/actions';
+import { Datasets } from '@kepler.gl/table';
+declare type AddDataButtonProps = {
+    onClick: () => void;
+    isInactive: boolean;
+};
+declare type DatasetSectionProps = {
+    datasets: Datasets;
+    defaultDataset: string;
+    showDatasetList: boolean;
+    showDeleteDataset: boolean;
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;
+    showAddDataModal: () => void;
+};
+export declare function AddDataButtonFactory(): React.FC<AddDataButtonProps>;
+declare function DatasetSectionFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, AddDataButton: ReturnType<typeof AddDataButtonFactory>): React.FC<DatasetSectionProps>;
+declare namespace DatasetSectionFactory {
+    var deps: (typeof SourceDataCatalogFactory | typeof AddDataButtonFactory)[];
+}
+export default DatasetSectionFactory;

package/dist/side-panel/layer-panel/dataset-section.js

@@ -0,0 +1,112 @@
+// 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.AddDataButtonFactory = AddDataButtonFactory;
+exports["default"] = void 0;
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _icons = require("../../common/icons");
+
+var _styledComponents2 = require("../../common/styled-components");
+
+var _sourceDataCatalog = _interopRequireDefault(require("../common/source-data-catalog"));
+
+var _templateObject, _templateObject2;
+
+var StyledDatasetTitle = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  line-height: ", ";\n  font-weight: 400;\n  letter-spacing: 1.25px;\n  color: ", ";\n  font-size: 11px;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-bottom: ", ";\n"])), function (props) {
+  return props.theme.sidePanelTitleLineHeight;
+}, function (props) {
+  return props.theme.subtextColor;
+}, function (props) {
+  return props.showDatasetList ? '16px' : '4px';
+});
+
+var StyledDatasetSection = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  margin: 0 -32px 0 -16px;\n  padding: 0 32px 0 16px;\n  border-bottom: 1px solid ", ";\n"])), function (props) {
+  return props.theme.sidePanelBorderColor;
+});
+
+function AddDataButtonFactory() {
+  var AddDataButton = /*#__PURE__*/_react["default"].memo(function (_ref) {
+    var onClick = _ref.onClick,
+        isInactive = _ref.isInactive;
+    return /*#__PURE__*/_react["default"].createElement(_styledComponents2.Button, {
+      className: "add-data-button",
+      onClick: onClick,
+      inactive: !isInactive,
+      width: "105px",
+      secondary: true
+    }, /*#__PURE__*/_react["default"].createElement(_icons.Add, {
+      height: "12px"
+    }), /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'layerManager.addData'
+    }));
+  });
+
+  AddDataButton.displayName = 'AddDataButton';
+  return AddDataButton;
+}
+
+DatasetSectionFactory.deps = [_sourceDataCatalog["default"], AddDataButtonFactory];
+
+function DatasetSectionFactory(SourceDataCatalog, AddDataButton) {
+  var DatasetSection = function DatasetSection(props) {
+    var datasets = props.datasets,
+        showDatasetTable = props.showDatasetTable,
+        updateTableColor = props.updateTableColor,
+        showDeleteDataset = props.showDeleteDataset,
+        removeDataset = props.removeDataset,
+        showDatasetList = props.showDatasetList,
+        showAddDataModal = props.showAddDataModal,
+        defaultDataset = props.defaultDataset;
+    var datasetCount = Object.keys(datasets).length;
+    return /*#__PURE__*/_react["default"].createElement(StyledDatasetSection, null, /*#__PURE__*/_react["default"].createElement(StyledDatasetTitle, {
+      showDatasetList: showDatasetList
+    }, /*#__PURE__*/_react["default"].createElement("span", null, "Datasets (", datasetCount, ")"), /*#__PURE__*/_react["default"].createElement(AddDataButton, {
+      onClick: showAddDataModal,
+      isInactive: !defaultDataset
+    })), showDatasetList && /*#__PURE__*/_react["default"].createElement(SourceDataCatalog, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: showDeleteDataset
+    }));
+  };
+
+  return DatasetSection;
+}
+
+var _default = DatasetSectionFactory;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/side-panel/layer-panel/dataset-section.tsx"],"names":["StyledDatasetTitle","styled","div","props","theme","sidePanelTitleLineHeight","subtextColor","showDatasetList","StyledDatasetSection","sidePanelBorderColor","AddDataButtonFactory","AddDataButton","React","memo","onClick","isInactive","displayName","DatasetSectionFactory","deps","SourceDataCatalogFactory","SourceDataCatalog","DatasetSection","datasets","showDatasetTable","updateTableColor","showDeleteDataset","removeDataset","showAddDataModal","defaultDataset","datasetCount","Object","keys","length"],"mappings":";;;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AAEA;;;;AAoBA,IAAMA,kBAAkB,GAAGC,6BAAOC,GAAV,wSACP,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYC,wBAAhB;AAAA,CADE,EAIb,UAAAF,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYE,YAAhB;AAAA,CAJQ,EASL,UAAAH,KAAK;AAAA,SAAKA,KAAK,CAACI,eAAN,GAAwB,MAAxB,GAAiC,KAAtC;AAAA,CATA,CAAxB;;AAYA,IAAMC,oBAAoB,GAAGP,6BAAOC,GAAV,oLAGG,UAAAC,KAAK;AAAA,SAAIA,KAAK,CAACC,KAAN,CAAYK,oBAAhB;AAAA,CAHR,CAA1B;;AAMO,SAASC,oBAAT,GAAgC;AACrC,MAAMC,aAA2C,gBAAGC,kBAAMC,IAAN,CAAW;AAAA,QAAEC,OAAF,QAAEA,OAAF;AAAA,QAAWC,UAAX,QAAWA,UAAX;AAAA,wBAC7D,gCAAC,yBAAD;AACE,MAAA,SAAS,EAAC,iBADZ;AAEE,MAAA,OAAO,EAAED,OAFX;AAGE,MAAA,QAAQ,EAAE,CAACC,UAHb;AAIE,MAAA,KAAK,EAAC,OAJR;AAKE,MAAA,SAAS;AALX,oBAOE,gCAAC,UAAD;AAAK,MAAA,MAAM,EAAC;AAAZ,MAPF,eAQE,gCAAC,8BAAD;AAAkB,MAAA,EAAE,EAAE;AAAtB,MARF,CAD6D;AAAA,GAAX,CAApD;;AAYAJ,EAAAA,aAAa,CAACK,WAAd,GAA4B,eAA5B;AACA,SAAOL,aAAP;AACD;;AAEDM,qBAAqB,CAACC,IAAtB,GAA6B,CAACC,6BAAD,EAA2BT,oBAA3B,CAA7B;;AAEA,SAASO,qBAAT,CACEG,iBADF,EAEET,aAFF,EAGE;AACA,MAAMU,cAA6C,GAAG,SAAhDA,cAAgD,CAAAlB,KAAK,EAAI;AAAA,QAE3DmB,QAF2D,GAUzDnB,KAVyD,CAE3DmB,QAF2D;AAAA,QAG3DC,gBAH2D,GAUzDpB,KAVyD,CAG3DoB,gBAH2D;AAAA,QAI3DC,gBAJ2D,GAUzDrB,KAVyD,CAI3DqB,gBAJ2D;AAAA,QAK3DC,iBAL2D,GAUzDtB,KAVyD,CAK3DsB,iBAL2D;AAAA,QAM3DC,aAN2D,GAUzDvB,KAVyD,CAM3DuB,aAN2D;AAAA,QAO3DnB,eAP2D,GAUzDJ,KAVyD,CAO3DI,eAP2D;AAAA,QAQ3DoB,gBAR2D,GAUzDxB,KAVyD,CAQ3DwB,gBAR2D;AAAA,QAS3DC,cAT2D,GAUzDzB,KAVyD,CAS3DyB,cAT2D;AAW7D,QAAMC,YAAY,GAAGC,MAAM,CAACC,IAAP,CAAYT,QAAZ,EAAsBU,MAA3C;AAEA,wBACE,gCAAC,oBAAD,qBACE,gCAAC,kBAAD;AAAoB,MAAA,eAAe,EAAEzB;AAArC,oBACE,4DAAiBsB,YAAjB,MADF,eAEE,gCAAC,aAAD;AAAe,MAAA,OAAO,EAAEF,gBAAxB;AAA0C,MAAA,UAAU,EAAE,CAACC;AAAvD,MAFF,CADF,EAKGrB,eAAe,iBACd,gCAAC,iBAAD;AACE,MAAA,QAAQ,EAAEe,QADZ;AAEE,MAAA,gBAAgB,EAAEC,gBAFpB;AAGE,MAAA,gBAAgB,EAAEC,gBAHpB;AAIE,MAAA,aAAa,EAAEE,aAJjB;AAKE,MAAA,iBAAiB,EAAED;AALrB,MANJ,CADF;AAiBD,GA9BD;;AAgCA,SAAOJ,cAAP;AACD;;eAEcJ,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 from 'react';\nimport styled from 'styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {Add} from '../../common/icons';\nimport {Button} from '../../common/styled-components';\n\nimport SourceDataCatalogFactory from '../common/source-data-catalog';\nimport {UIStateActions, VisStateActions, ActionHandler} from '@kepler.gl/actions';\nimport {Datasets} from '@kepler.gl/table';\n\ntype AddDataButtonProps = {\n  onClick: () => void;\n  isInactive: boolean;\n};\n\ntype DatasetSectionProps = {\n  datasets: Datasets;\n  defaultDataset: string;\n  showDatasetList: boolean;\n  showDeleteDataset: boolean;\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;\n  showAddDataModal: () => void;\n};\n\nconst StyledDatasetTitle = styled.div<{showDatasetList: boolean}>`\n  line-height: ${props => props.theme.sidePanelTitleLineHeight};\n  font-weight: 400;\n  letter-spacing: 1.25px;\n  color: ${props => props.theme.subtextColor};\n  font-size: 11px;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-bottom: ${props => (props.showDatasetList ? '16px' : '4px')};\n`;\n\nconst StyledDatasetSection = styled.div`\n  margin: 0 -32px 0 -16px;\n  padding: 0 32px 0 16px;\n  border-bottom: 1px solid ${props => props.theme.sidePanelBorderColor};\n`;\n\nexport function AddDataButtonFactory() {\n  const AddDataButton: React.FC<AddDataButtonProps> = React.memo(({onClick, isInactive}) => (\n    <Button\n      className=\"add-data-button\"\n      onClick={onClick}\n      inactive={!isInactive}\n      width=\"105px\"\n      secondary\n    >\n      <Add height=\"12px\" />\n      <FormattedMessage id={'layerManager.addData'} />\n    </Button>\n  ));\n  AddDataButton.displayName = 'AddDataButton';\n  return AddDataButton;\n}\n\nDatasetSectionFactory.deps = [SourceDataCatalogFactory, AddDataButtonFactory];\n\nfunction DatasetSectionFactory(\n  SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>,\n  AddDataButton: ReturnType<typeof AddDataButtonFactory>\n) {\n  const DatasetSection: React.FC<DatasetSectionProps> = props => {\n    const {\n      datasets,\n      showDatasetTable,\n      updateTableColor,\n      showDeleteDataset,\n      removeDataset,\n      showDatasetList,\n      showAddDataModal,\n      defaultDataset\n    } = props;\n    const datasetCount = Object.keys(datasets).length;\n\n    return (\n      <StyledDatasetSection>\n        <StyledDatasetTitle showDatasetList={showDatasetList}>\n          <span>Datasets ({datasetCount})</span>\n          <AddDataButton onClick={showAddDataModal} isInactive={!defaultDataset} />\n        </StyledDatasetTitle>\n        {showDatasetList && (\n          <SourceDataCatalog\n            datasets={datasets}\n            showDatasetTable={showDatasetTable}\n            updateTableColor={updateTableColor}\n            removeDataset={removeDataset}\n            showDeleteDataset={showDeleteDataset}\n          />\n        )}\n      </StyledDatasetSection>\n    );\n  };\n\n  return DatasetSection;\n}\n\nexport default DatasetSectionFactory;\n"]}

package/dist/side-panel/layer-panel/dimension-scale-selector.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+declare type DimensionScaleSelectorProps = {
+    label: string;
+    onSelect: (val: readonly (string | number | boolean | object)[] | string | number | boolean | object | null) => void;
+    options: string[];
+    scaleType?: string;
+    disabled?: boolean;
+};
+declare const DimensionScaleSelector: React.FC<DimensionScaleSelectorProps>;
+export default DimensionScaleSelector;

package/dist/side-panel/layer-panel/dimension-scale-selector.js

@@ -0,0 +1,60 @@
+// 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 _react = _interopRequireDefault(require("react"));
+
+var _styledComponents = require("../../common/styled-components");
+
+var _itemSelector = _interopRequireDefault(require("../../common/item-selector/item-selector"));
+
+var _localization = require("@kepler.gl/localization");
+
+var _utils = require("@kepler.gl/utils");var DimensionScaleSelector = function DimensionScaleSelector(_ref) {
+  var label = _ref.label,
+      onSelect = _ref.onSelect,
+      options = _ref.options,
+      scaleType = _ref.scaleType,
+      _ref$disabled = _ref.disabled,
+      disabled = _ref$disabled === void 0 ? false : _ref$disabled;
+  return /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, /*#__PURE__*/_react["default"].createElement(_styledComponents.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: label ? "scale.".concat((0, _utils.camelize)(label)) : 'misc.scale',
+    defaultMessage: label
+  })), /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], {
+    disabled: disabled,
+    selectedItems: scaleType,
+    options: options,
+    multiSelect: false,
+    searchable: false,
+    onChange: onSelect
+  }));
+};
+
+var _default = DimensionScaleSelector;
+exports["default"] = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/side-panel/layer-panel/how-to-button.d.ts

@@ -0,0 +1,6 @@
+import React, { MouseEventHandler } from 'react';
+export declare type HowToButtonProps = {
+    onClick: MouseEventHandler;
+};
+export declare const HowToButton: React.FC<HowToButtonProps>;
+export default HowToButton;