@carto/kepler.gl 0.0.81 → 0.0.82

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

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _datasetLayerSection = _interopRequireDefault(require("./dataset-layer-section"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// 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.
+
+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 !!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 = exports["default"] = DatasetLayerGroupFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_datasetLayerSection","_interopRequireDefault","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","DatasetLayerGroupFactory","deps","DatasetLayerSectionFactory","DatasetLayerSection","DatasetLayerGroup","props","datasets","showDatasetTable","layers","updateTableColor","showDeleteDataset","removeDataset","layerOrder","layerClasses","uiStateActions","visStateActions","datasetLayerSectionData","useMemo","values","map","dataset","datasetLayers","layer","config","dataId","id","filter","createElement","Fragment","dlsData","key","_default","exports"],"sources":["../../../../src/components/side-panel/layer-panel/dataset-layer-group.tsx"],"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, {useMemo} from 'react';\n\nimport DatasetLayerSectionFactory from './dataset-layer-section';\nimport {Datasets} from 'reducers';\nimport {Layer, LayerClassesType} from 'layers';\nimport * as UiStateActions from 'actions/ui-state-actions';\nimport * as VisStateActions from 'actions/vis-state-actions';\nimport {ActionHandler} from 'actions';\n\ntype DatasetLayerGroupProps = {\n  datasets: Datasets;\n  layers: Layer[];\n  layerOrder: number[];\n  layerClasses: LayerClassesType;\n  showDeleteDataset: boolean;\n  removeDataset: ActionHandler<typeof UiStateActions.openDeleteModal>;\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  uiStateActions: typeof UiStateActions;\n  visStateActions: typeof VisStateActions;\n};\n\nDatasetLayerGroupFactory.deps = [DatasetLayerSectionFactory];\n\nfunction DatasetLayerGroupFactory(\n  DatasetLayerSection: ReturnType<typeof DatasetLayerSectionFactory>\n) {\n  const DatasetLayerGroup: React.FC<DatasetLayerGroupProps> = props => {\n    const {\n      datasets,\n      showDatasetTable,\n      layers,\n      updateTableColor,\n      showDeleteDataset,\n      removeDataset,\n      layerOrder,\n      layerClasses,\n      uiStateActions,\n      visStateActions\n    } = props;\n\n    const datasetLayerSectionData = useMemo(() => {\n      return Object.values(datasets).map(dataset => {\n        // Global layer order will contain the correct order of layers\n        // We just empty the positions in layers array (for each dataset)\n        // where the layer doesn't belong to a dataset and set it to null\n        const datasetLayers = layers\n          .map(layer => (layer.config.dataId === dataset.id ? layer : null))\n          .filter(layer => !!layer);\n\n        return {dataset, datasetLayers};\n      });\n    }, [datasets, layers]);\n\n    return (\n      <>\n        {datasetLayerSectionData.map(dlsData => (\n          <DatasetLayerSection\n            key={dlsData.dataset.id}\n            dataset={dlsData.dataset}\n            layers={dlsData.datasetLayers as Layer[]}\n            showDatasetTable={showDatasetTable}\n            updateTableColor={updateTableColor}\n            showDeleteDataset={showDeleteDataset}\n            removeDataset={removeDataset}\n            layerOrder={layerOrder}\n            layerClasses={layerClasses}\n            uiStateActions={uiStateActions}\n            visStateActions={visStateActions}\n          />\n        ))}\n      </>\n    );\n  };\n\n  return DatasetLayerGroup;\n}\n\nexport default DatasetLayerGroupFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,25 @@
+import React from 'react';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import LayerListFactory from './layer-list';
+import { Layer, LayerClassesType } from 'layers';
+import KeplerTable from 'utils/table-utils/kepler-table';
+import * as UiStateActions from 'actions/ui-state-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+import { ActionHandler } from 'actions';
+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/components/side-panel/layer-panel/dataset-layer-section.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+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; // 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.
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+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 = exports["default"] = DatasetLayerSectionFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_interopRequireDefault","_sourceDataCatalog","_layerList","_templateObject","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","DatasetLayerSectionWrapper","styled","div","attrs","className","_taggedTemplateLiteral2","DatasetLayerSectionFactory","deps","SourceDataCatalogFactory","LayerListFactory","SourceDataCatalog","LayerList","DatasetLayerSection","props","dataset","showDatasetTable","layers","updateTableColor","showDeleteDataset","removeDataset","layerOrder","layerClasses","uiStateActions","visStateActions","datasets","useMemo","_defineProperty2","id","createElement","isSortable","_default","exports"],"sources":["../../../../src/components/side-panel/layer-panel/dataset-layer-section.tsx"],"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, {useMemo} from 'react';\nimport styled from 'styled-components';\n\nimport SourceDataCatalogFactory from '../common/source-data-catalog';\nimport LayerListFactory from './layer-list';\nimport {Layer, LayerClassesType} from 'layers';\nimport KeplerTable from 'utils/table-utils/kepler-table';\nimport * as UiStateActions from 'actions/ui-state-actions';\nimport * as VisStateActions from 'actions/vis-state-actions';\nimport {ActionHandler} from 'actions';\n\ntype DatasetLayerSectionProps = {\n  dataset: KeplerTable;\n  layers: Layer[];\n  layerOrder: number[];\n  layerClasses: LayerClassesType;\n  showDeleteDataset: boolean;\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  removeDataset: ActionHandler<typeof UiStateActions.openDeleteModal>;\n  uiStateActions: typeof UiStateActions;\n  visStateActions: typeof VisStateActions;\n};\n\nconst DatasetLayerSectionWrapper = styled.div.attrs({\n  className: 'dataset-layer-section'\n})`\n  margin-bottom: 16px;\n`;\n\nDatasetLayerSectionFactory.deps = [SourceDataCatalogFactory, LayerListFactory];\n\nfunction DatasetLayerSectionFactory(\n  SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>,\n  LayerList: ReturnType<typeof LayerListFactory>\n) {\n  const DatasetLayerSection: React.FC<DatasetLayerSectionProps> = props => {\n    const {\n      dataset,\n      showDatasetTable,\n      layers,\n      updateTableColor,\n      showDeleteDataset,\n      removeDataset,\n      layerOrder,\n      layerClasses,\n      uiStateActions,\n      visStateActions\n    } = props;\n\n    const datasets = useMemo(() => {\n      return {[dataset.id]: dataset};\n    }, [dataset]);\n\n    return (\n      <DatasetLayerSectionWrapper>\n        <SourceDataCatalog\n          datasets={datasets}\n          showDatasetTable={showDatasetTable}\n          updateTableColor={updateTableColor}\n          removeDataset={removeDataset}\n          showDeleteDataset={showDeleteDataset}\n        />\n        <LayerList\n          datasets={datasets}\n          layerOrder={layerOrder}\n          layers={layers}\n          layerClasses={layerClasses}\n          uiStateActions={uiStateActions}\n          visStateActions={visStateActions}\n          isSortable={false}\n        />\n      </DatasetLayerSectionWrapper>\n    );\n  };\n\n  return DatasetLayerSection;\n}\n\nexport default DatasetLayerSectionFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,26 @@
+import React from 'react';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import { Datasets } from 'reducers';
+import * as UiStateActions from 'actions/ui-state-actions';
+import * as VisStateActions from 'actions/vis-state-actions';
+import { ActionHandler } from 'actions';
+type AddDataButtonProps = {
+    onClick: () => void;
+    isInactive: boolean;
+};
+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/components/side-panel/layer-panel/dataset-section.js

@@ -0,0 +1,91 @@
+"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("../../../localization");
+var _icons = require("../../common/icons");
+var _styledComponents2 = require("../../common/styled-components");
+var _sourceDataCatalog = _interopRequireDefault(require("../common/source-data-catalog"));
+var _templateObject, _templateObject2; // 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.
+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 = function AddDataButton(_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'
+    }));
+  };
+  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 = exports["default"] = DatasetSectionFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_styledComponents","_localization","_icons","_styledComponents2","_sourceDataCatalog","_templateObject","_templateObject2","StyledDatasetTitle","styled","div","_taggedTemplateLiteral2","props","theme","sidePanelTitleLineHeight","subtextColor","showDatasetList","StyledDatasetSection","sidePanelBorderColor","AddDataButtonFactory","AddDataButton","_ref","onClick","isInactive","createElement","Button","className","inactive","width","secondary","Add","height","FormattedMessage","id","DatasetSectionFactory","deps","SourceDataCatalogFactory","SourceDataCatalog","DatasetSection","datasets","showDatasetTable","updateTableColor","showDeleteDataset","removeDataset","showAddDataModal","defaultDataset","datasetCount","Object","keys","length","_default","exports"],"sources":["../../../../src/components/side-panel/layer-panel/dataset-section.tsx"],"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 'localization';\nimport {Add} from 'components/common/icons';\nimport {Button} from 'components/common/styled-components';\n\nimport SourceDataCatalogFactory from '../common/source-data-catalog';\nimport {Datasets} from 'reducers';\nimport * as UiStateActions from 'actions/ui-state-actions';\nimport * as VisStateActions from 'actions/vis-state-actions';\nimport {ActionHandler} from 'actions';\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> = ({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\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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import React from 'react';
+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/components/side-panel/layer-panel/dimension-scale-selector.js

@@ -50,4 +50,4 @@ var DimensionScaleSelector = function DimensionScaleSelector(_ref) {
   }));
 };
 var _default = exports["default"] = DimensionScaleSelector;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVhY3QiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9zdHlsZWRDb21wb25lbnRzIiwiX2l0ZW1TZWxlY3RvciIsIl9sb2NhbGl6YXRpb24iLCJfdXRpbHMiLCJEaW1lbnNpb25TY2FsZVNlbGVjdG9yIiwiX3JlZiIsImxhYmVsIiwib25TZWxlY3QiLCJvcHRpb25zIiwic2NhbGVUeXBlIiwiX3JlZiRkaXNhYmxlZCIsImRpc2FibGVkIiwiY3JlYXRlRWxlbWVudCIsIlNpZGVQYW5lbFNlY3Rpb24iLCJQYW5lbExhYmVsIiwiRm9ybWF0dGVkTWVzc2FnZSIsImlkIiwiY29uY2F0IiwiY2FtZWxpemUiLCJkZWZhdWx0TWVzc2FnZSIsInNlbGVjdGVkSXRlbXMiLCJtdWx0aVNlbGVjdCIsInNlYXJjaGFibGUiLCJvbkNoYW5nZSIsIl9kZWZhdWx0IiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3NpZGUtcGFuZWwvbGF5ZXItcGFuZWwvZGltZW5zaW9uLXNjYWxlLXNlbGVjdG9yLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIDIwMjIgVWJlciBUZWNobm9sb2dpZXMsIEluYy5cbi8vXG4vLyBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4vLyBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4vLyBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4vLyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4vLyBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbi8vIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4vL1xuLy8gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW5cbi8vIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuLy9cbi8vIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1Jcbi8vIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuLy8gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4vLyBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4vLyBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuLy8gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTlxuLy8gVEhFIFNPRlRXQVJFLlxuXG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuaW1wb3J0IHtQYW5lbExhYmVsLCBTaWRlUGFuZWxTZWN0aW9ufSBmcm9tICdjb21wb25lbnRzL2NvbW1vbi9zdHlsZWQtY29tcG9uZW50cyc7XG5pbXBvcnQgSXRlbVNlbGVjdG9yIGZyb20gJ2NvbXBvbmVudHMvY29tbW9uL2l0ZW0tc2VsZWN0b3IvaXRlbS1zZWxlY3Rvcic7XG5pbXBvcnQge0Zvcm1hdHRlZE1lc3NhZ2V9IGZyb20gJ2xvY2FsaXphdGlvbic7XG5pbXBvcnQge2NhbWVsaXplfSBmcm9tICd1dGlscy91dGlscyc7XG5cbnR5cGUgRGltZW5zaW9uU2NhbGVTZWxlY3RvclByb3BzID0ge1xuICBsYWJlbDogc3RyaW5nO1xuICBvblNlbGVjdDogKFxuICAgIHZhbDogcmVhZG9ubHkgKHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4gfCBvYmplY3QpW10gfCBzdHJpbmcgfCBudW1iZXIgfCBib29sZWFuIHwgb2JqZWN0IHwgbnVsbFxuICApID0+IHZvaWQ7XG4gIG9wdGlvbnM6IHN0cmluZ1tdO1xuICBzY2FsZVR5cGU/OiBzdHJpbmc7XG4gIGRpc2FibGVkPzogYm9vbGVhbjtcbn07XG5cbmNvbnN0IERpbWVuc2lvblNjYWxlU2VsZWN0b3I6IFJlYWN0LkZDPERpbWVuc2lvblNjYWxlU2VsZWN0b3JQcm9wcz4gPSAoe1xuICBsYWJlbCxcbiAgb25TZWxlY3QsXG4gIG9wdGlvbnMsXG4gIHNjYWxlVHlwZSxcbiAgZGlzYWJsZWQgPSBmYWxzZVxufSkgPT4ge1xuICByZXR1cm4gKFxuICAgIDxTaWRlUGFuZWxTZWN0aW9uPlxuICAgICAgPFBhbmVsTGFiZWw+XG4gICAgICAgIDxGb3JtYXR0ZWRNZXNzYWdlXG4gICAgICAgICAgaWQ9e2xhYmVsID8gYHNjYWxlLiR7Y2FtZWxpemUobGFiZWwpfWAgOiAnbWlzYy5zY2FsZSd9XG4gICAgICAgICAgZGVmYXVsdE1lc3NhZ2U9e2xhYmVsfVxuICAgICAgICAvPlxuICAgICAgPC9QYW5lbExhYmVsPlxuICAgICAgPEl0ZW1TZWxlY3RvclxuICAgICAgICBkaXNhYmxlZD17ZGlzYWJsZWR9XG4gICAgICAgIHNlbGVjdGVkSXRlbXM9e3NjYWxlVHlwZX1cbiAgICAgICAgb3B0aW9ucz17b3B0aW9uc31cbiAgICAgICAgbXVsdGlTZWxlY3Q9e2ZhbHNlfVxuICAgICAgICBzZWFyY2hhYmxlPXtmYWxzZX1cbiAgICAgICAgb25DaGFuZ2U9e29uU2VsZWN0fVxuICAgICAgLz5cbiAgICA8L1NpZGVQYW5lbFNlY3Rpb24+XG4gICk7XG59O1xuXG5leHBvcnQgZGVmYXVsdCBEaW1lbnNpb25TY2FsZVNlbGVjdG9yO1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBb0JBLElBQUFBLE1BQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFDLGlCQUFBLEdBQUFELE9BQUE7QUFDQSxJQUFBRSxhQUFBLEdBQUFILHNCQUFBLENBQUFDLE9BQUE7QUFDQSxJQUFBRyxhQUFBLEdBQUFILE9BQUE7QUFDQSxJQUFBSSxNQUFBLEdBQUFKLE9BQUE7QUF4QkE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7O0FBa0JBLElBQU1LLHNCQUE2RCxHQUFHLFNBQWhFQSxzQkFBNkRBLENBQUFDLElBQUEsRUFNN0Q7RUFBQSxJQUxKQyxLQUFLLEdBQUFELElBQUEsQ0FBTEMsS0FBSztJQUNMQyxRQUFRLEdBQUFGLElBQUEsQ0FBUkUsUUFBUTtJQUNSQyxPQUFPLEdBQUFILElBQUEsQ0FBUEcsT0FBTztJQUNQQyxTQUFTLEdBQUFKLElBQUEsQ0FBVEksU0FBUztJQUFBQyxhQUFBLEdBQUFMLElBQUEsQ0FDVE0sUUFBUTtJQUFSQSxRQUFRLEdBQUFELGFBQUEsY0FBRyxLQUFLLEdBQUFBLGFBQUE7RUFFaEIsb0JBQ0ViLE1BQUEsWUFBQWUsYUFBQSxDQUFDWixpQkFBQSxDQUFBYSxnQkFBZ0IscUJBQ2ZoQixNQUFBLFlBQUFlLGFBQUEsQ0FBQ1osaUJBQUEsQ0FBQWMsVUFBVSxxQkFDVGpCLE1BQUEsWUFBQWUsYUFBQSxDQUFDVixhQUFBLENBQUFhLGdCQUFnQjtJQUNmQyxFQUFFLEVBQUVWLEtBQUssWUFBQVcsTUFBQSxDQUFZLElBQUFDLGVBQVEsRUFBQ1osS0FBSyxDQUFDLElBQUssWUFBYTtJQUN0RGEsY0FBYyxFQUFFYjtFQUFNLENBQ3ZCLENBQ1MsQ0FBQyxlQUNiVCxNQUFBLFlBQUFlLGFBQUEsQ0FBQ1gsYUFBQSxXQUFZO0lBQ1hVLFFBQVEsRUFBRUEsUUFBUztJQUNuQlMsYUFBYSxFQUFFWCxTQUFVO0lBQ3pCRCxPQUFPLEVBQUVBLE9BQVE7SUFDakJhLFdBQVcsRUFBRSxLQUFNO0lBQ25CQyxVQUFVLEVBQUUsS0FBTTtJQUNsQkMsUUFBUSxFQUFFaEI7RUFBUyxDQUNwQixDQUNlLENBQUM7QUFFdkIsQ0FBQztBQUFDLElBQUFpQixRQUFBLEdBQUFDLE9BQUEsY0FFYXJCLHNCQUFzQiIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/components/side-panel/layer-panel/hex-column-config.d.ts

@@ -0,0 +1,62 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+export type HexColumnConfigFactoryProps = {
+    onSelectColumn: Function;
+    fields?: any[];
+    value?: string;
+    iconComponent?: React.ReactNode;
+};
+export declare function HexColumnConfigFactory(): {
+    new (props: HexColumnConfigFactoryProps): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<HexColumnConfigFactoryProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<HexColumnConfigFactoryProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: HexColumnConfigFactoryProps, context: any): {
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<HexColumnConfigFactoryProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<HexColumnConfigFactoryProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<HexColumnConfigFactoryProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<HexColumnConfigFactoryProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        fields: PropTypes.Requireable<any[]>;
+        value: PropTypes.Requireable<string>;
+        onSelectColumn: PropTypes.Validator<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any>;
+};

package/dist/components/side-panel/layer-panel/hex-column-config.js

@@ -19,17 +19,17 @@ var _localization = require("../../../localization");
 var _react = _interopRequireWildcard(require("react"));
 var _defaultSettings = require("../../../constants/default-settings");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function HexColumnConfigFactory() {
   var HexColumnConfig = /*#__PURE__*/function (_Component) {
-    (0, _inherits2["default"])(HexColumnConfig, _Component);
     function HexColumnConfig() {
       (0, _classCallCheck2["default"])(this, HexColumnConfig);
       return _callSuper(this, HexColumnConfig, arguments);
     }
-    (0, _createClass2["default"])(HexColumnConfig, [{
+    (0, _inherits2["default"])(HexColumnConfig, _Component);
+    return (0, _createClass2["default"])(HexColumnConfig, [{
       key: "render",
       value: function render() {
         var _this$props = this.props,
@@ -63,7 +63,6 @@ function HexColumnConfigFactory() {
         })));
       }
     }]);
-    return HexColumnConfig;
   }(_react.Component);
   (0, _defineProperty2["default"])(HexColumnConfig, "propTypes", {
     fields: _propTypes["default"].arrayOf(_propTypes["default"].any),
@@ -72,4 +71,4 @@ function HexColumnConfigFactory() {
   });
   return HexColumnConfig;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/side-panel/layer-panel/layer-aggregation-resolution.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare function LayerAggregationResolutionFactory(): React.FC<import("react-intl").WithIntlProps<import("react-intl").WrappedComponentProps<any>>> & {
+    WrappedComponent: React.ComponentType<import("react-intl").WrappedComponentProps<any>>;
+};
+declare namespace LayerAggregationResolutionFactory {
+    var deps: any[];
+}
+export default LayerAggregationResolutionFactory;

package/dist/components/side-panel/layer-panel/layer-aggregation-resolution.js

@@ -15,4 +15,4 @@ function LayerAggregationResolutionFactory() {
   return (0, _reactIntl.injectIntl)(LayerAggregationResolution);
 }
 var _default = exports["default"] = LayerAggregationResolutionFactory;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVhY3QiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9yZWFjdEludGwiLCJMYXllckFnZ3JlZ2F0aW9uUmVzb2x1dGlvbkZhY3RvcnkiLCJkZXBzIiwiTGF5ZXJBZ2dyZWdhdGlvblJlc29sdXRpb24iLCJjcmVhdGVFbGVtZW50IiwiaW5qZWN0SW50bCIsIl9kZWZhdWx0IiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3NpZGUtcGFuZWwvbGF5ZXItcGFuZWwvbGF5ZXItYWdncmVnYXRpb24tcmVzb2x1dGlvbi5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuaW1wb3J0IHtpbmplY3RJbnRsfSBmcm9tICdyZWFjdC1pbnRsJztcblxuTGF5ZXJBZ2dyZWdhdGlvblJlc29sdXRpb25GYWN0b3J5LmRlcHMgPSBbXTtcbmZ1bmN0aW9uIExheWVyQWdncmVnYXRpb25SZXNvbHV0aW9uRmFjdG9yeSgpIHtcbiAgY29uc3QgTGF5ZXJBZ2dyZWdhdGlvblJlc29sdXRpb24gPSAoKSA9PiB7XG4gICAgcmV0dXJuIDxkaXY+Q29tcG9uZW50IHJlcGxhY2VkIGJ5IGNsb3VkIG5hdGl2ZTwvZGl2PjtcbiAgfTtcblxuICByZXR1cm4gaW5qZWN0SW50bChMYXllckFnZ3JlZ2F0aW9uUmVzb2x1dGlvbik7XG59XG5cbmV4cG9ydCBkZWZhdWx0IExheWVyQWdncmVnYXRpb25SZXNvbHV0aW9uRmFjdG9yeTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBLElBQUFBLE1BQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFDLFVBQUEsR0FBQUQsT0FBQTtBQUVBRSxpQ0FBaUMsQ0FBQ0MsSUFBSSxHQUFHLEVBQUU7QUFDM0MsU0FBU0QsaUNBQWlDQSxDQUFBLEVBQUc7RUFDM0MsSUFBTUUsMEJBQTBCLEdBQUcsU0FBN0JBLDBCQUEwQkEsQ0FBQSxFQUFTO0lBQ3ZDLG9CQUFPTixNQUFBLFlBQUFPLGFBQUEsY0FBSyxvQ0FBdUMsQ0FBQztFQUN0RCxDQUFDO0VBRUQsT0FBTyxJQUFBQyxxQkFBVSxFQUFDRiwwQkFBMEIsQ0FBQztBQUMvQztBQUFDLElBQUFHLFFBQUEsR0FBQUMsT0FBQSxjQUVjTixpQ0FBaUMifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVhY3QiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9yZWFjdEludGwiLCJMYXllckFnZ3JlZ2F0aW9uUmVzb2x1dGlvbkZhY3RvcnkiLCJkZXBzIiwiTGF5ZXJBZ2dyZWdhdGlvblJlc29sdXRpb24iLCJjcmVhdGVFbGVtZW50IiwiaW5qZWN0SW50bCIsIl9kZWZhdWx0IiwiZXhwb3J0cyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3NpZGUtcGFuZWwvbGF5ZXItcGFuZWwvbGF5ZXItYWdncmVnYXRpb24tcmVzb2x1dGlvbi50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7aW5qZWN0SW50bH0gZnJvbSAncmVhY3QtaW50bCc7XG5cbkxheWVyQWdncmVnYXRpb25SZXNvbHV0aW9uRmFjdG9yeS5kZXBzID0gW107XG5mdW5jdGlvbiBMYXllckFnZ3JlZ2F0aW9uUmVzb2x1dGlvbkZhY3RvcnkoKSB7XG4gIGNvbnN0IExheWVyQWdncmVnYXRpb25SZXNvbHV0aW9uID0gKCkgPT4ge1xuICAgIHJldHVybiA8ZGl2PkNvbXBvbmVudCByZXBsYWNlZCBieSBjbG91ZCBuYXRpdmU8L2Rpdj47XG4gIH07XG5cbiAgcmV0dXJuIGluamVjdEludGwoTGF5ZXJBZ2dyZWdhdGlvblJlc29sdXRpb24pO1xufVxuXG5leHBvcnQgZGVmYXVsdCBMYXllckFnZ3JlZ2F0aW9uUmVzb2x1dGlvbkZhY3Rvcnk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQSxJQUFBQSxNQUFBLEdBQUFDLHNCQUFBLENBQUFDLE9BQUE7QUFDQSxJQUFBQyxVQUFBLEdBQUFELE9BQUE7QUFFQUUsaUNBQWlDLENBQUNDLElBQUksR0FBRyxFQUFFO0FBQzNDLFNBQVNELGlDQUFpQ0EsQ0FBQSxFQUFHO0VBQzNDLElBQU1FLDBCQUEwQixHQUFHLFNBQTdCQSwwQkFBMEJBLENBQUEsRUFBUztJQUN2QyxvQkFBT04sTUFBQSxZQUFBTyxhQUFBLGNBQUssb0NBQXVDLENBQUM7RUFDdEQsQ0FBQztFQUVELE9BQU8sSUFBQUMscUJBQVUsRUFBQ0YsMEJBQTBCLENBQUM7QUFDL0M7QUFBQyxJQUFBRyxRQUFBLEdBQUFDLE9BQUEsY0FFY04saUNBQWlDIiwiaWdub3JlTGlzdCI6W119

package/dist/components/side-panel/layer-panel/layer-column-config.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import ColumnSelectorFactory from './column-selector';
+import { ColumnPairs } from 'layers/base-layer';
+import { Layer, LayerColumns, LayerBaseConfig } from 'layers';
+import { Field, FieldPair } from 'utils/table-utils/kepler-table';
+type LayerColumnConfigProps = {
+    columnPairs?: ColumnPairs | null;
+    fieldPairs?: FieldPair[];
+    columns: LayerColumns;
+    columnLabels?: Record<string, string>;
+    fields: Field[];
+    updateLayerConfig: (newConfig: Partial<LayerBaseConfig>) => void;
+    assignColumn: Layer['assignColumn'];
+    assignColumnPairs: Layer['assignColumnPairs'];
+};
+declare function LayerColumnConfigFactory(ColumnSelector: ReturnType<typeof ColumnSelectorFactory>): React.FC<LayerColumnConfigProps>;
+declare namespace LayerColumnConfigFactory {
+    var deps: (typeof ColumnSelectorFactory)[];
+}
+export default LayerColumnConfigFactory;