@kepler.gl/components 3.3.0-alpha.4 → 3.3.0-alpha.6

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

@@ -0,0 +1,217 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _excluded = ["rasterTile"],
+  _excluded2 = ["wms"],
+  _excluded3 = ["flow"];
+var _templateObject, _templateObject2;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import { injectIntl } from 'react-intl';
+import styled from 'styled-components';
+import { FormattedMessage } from '@kepler.gl/localization';
+import LayerListFactory from './layer-panel/layer-list';
+import DatasetLayerGroupFactory from './layer-panel/dataset-layer-group';
+import PanelViewListToggleFactory from './panel-view-list-toggle';
+import PanelTitleFactory from './panel-title';
+import DatasetSectionFactory from './layer-panel/dataset-section';
+import AddLayerButtonFactory from './layer-panel/add-layer-button';
+import ItemSelector from '../common/item-selector/item-selector';
+import { PanelLabel, SidePanelDivider, SidePanelSection } from '../common/styled-components';
+import InfoHelperFactory from '../common/info-helper';
+import { LAYER_BLENDINGS, OVERLAY_BLENDINGS, PANEL_VIEW_TOGGLES } from '@kepler.gl/constants';
+import { getApplicationConfig } from '@kepler.gl/utils';
+import PanelHeaderActionFactory from './panel-header-action';
+import { Folder } from '../common/icons';
+export var LayerBlendingSelector = /*#__PURE__*/React.memo(function (_ref) {
+  var layerBlending = _ref.layerBlending,
+    updateLayerBlending = _ref.updateLayerBlending,
+    intl = _ref.intl,
+    className = _ref.className;
+  var labeledLayerBlendings = Object.keys(LAYER_BLENDINGS).reduce(function (acc, current) {
+    return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, intl.formatMessage({
+      id: LAYER_BLENDINGS[current].label
+    }), current));
+  }, {});
+  var onChange = useCallback(function (blending) {
+    return updateLayerBlending(labeledLayerBlendings[blending]);
+  }, [updateLayerBlending, labeledLayerBlendings]);
+  return /*#__PURE__*/React.createElement(SidePanelSection, {
+    className: className
+  }, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: "layerBlending.title"
+  })), /*#__PURE__*/React.createElement(ItemSelector, {
+    selectedItems: intl.formatMessage({
+      id: LAYER_BLENDINGS[layerBlending].label
+    }),
+    options: Object.keys(labeledLayerBlendings),
+    multiSelect: false,
+    searchable: false,
+    onChange: onChange
+  }));
+});
+LayerBlendingSelector.displayName = 'LayerBlendingSelector';
+var InfoHelperWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  float: right;\n"])));
+var OverlayBlendingSelectorTitleRow = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n"])));
+var OverlayBlendingSelector = /*#__PURE__*/React.memo(function (_ref2) {
+  var overlayBlending = _ref2.overlayBlending,
+    updateOverlayBlending = _ref2.updateOverlayBlending,
+    intl = _ref2.intl,
+    infoHelper = _ref2.infoHelper;
+  var labeledOverlayBlendings = Object.keys(OVERLAY_BLENDINGS).reduce(function (acc, current) {
+    return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, intl.formatMessage({
+      id: OVERLAY_BLENDINGS[current].label
+    }), current));
+  }, {});
+  var onChange = useCallback(function (blending) {
+    return updateOverlayBlending(labeledOverlayBlendings[blending]);
+  }, [updateOverlayBlending, labeledOverlayBlendings]);
+  return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(OverlayBlendingSelectorTitleRow, null, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: "overlayBlending.title"
+  })), /*#__PURE__*/React.createElement(InfoHelperWrapper, null, infoHelper)), /*#__PURE__*/React.createElement(ItemSelector, {
+    selectedItems: intl.formatMessage({
+      id: OVERLAY_BLENDINGS[overlayBlending].label
+    }),
+    options: Object.keys(labeledOverlayBlendings),
+    multiSelect: false,
+    searchable: false,
+    onChange: onChange
+  }));
+});
+OverlayBlendingSelector.displayName = 'OverlayBlendingSelector';
+LayerManagerFactory.deps = [LayerListFactory, DatasetLayerGroupFactory, PanelViewListToggleFactory, PanelTitleFactory, DatasetSectionFactory, AddLayerButtonFactory, InfoHelperFactory, PanelHeaderActionFactory];
+function LayerManagerFactory(LayerList, DatasetLayerGroup, PanelViewListToggle, PanelTitle, DatasetSection, AddLayerButton, InfoHelper, PanelHeaderAction) {
+  var LayerManager = function LayerManager(_ref3) {
+    var layers = _ref3.layers,
+      datasets = _ref3.datasets,
+      intl = _ref3.intl,
+      layerOrder = _ref3.layerOrder,
+      panelListView = _ref3.panelListView,
+      panelMetadata = _ref3.panelMetadata,
+      layerClasses = _ref3.layerClasses,
+      layerBlending = _ref3.layerBlending,
+      overlayBlending = _ref3.overlayBlending,
+      showAddDataModal = _ref3.showAddDataModal,
+      _ref3$showDeleteDatas = _ref3.showDeleteDataset,
+      showDeleteDataset = _ref3$showDeleteDatas === void 0 ? true : _ref3$showDeleteDatas,
+      updateTableColor = _ref3.updateTableColor,
+      showDatasetTable = _ref3.showDatasetTable,
+      removeDataset = _ref3.removeDataset,
+      uiStateActions = _ref3.uiStateActions,
+      visStateActions = _ref3.visStateActions,
+      mapStateActions = _ref3.mapStateActions,
+      mapState = _ref3.mapState;
+    var addLayer = visStateActions.addLayer;
+    var togglePanelListView = uiStateActions.togglePanelListView;
+    var onAddLayer = useCallback(function (dataset) {
+      addLayer(undefined, dataset);
+    }, [addLayer]);
+    var onAddGroup = useCallback(function () {
+      visStateActions.addLayerGroup({});
+    }, [visStateActions]);
+    var onTogglePanelListView = useCallback(function (listView) {
+      togglePanelListView({
+        panelId: 'layer',
+        listView: listView
+      });
+    }, [togglePanelListView]);
+    var isSortByDatasetMode = panelListView === PANEL_VIEW_TOGGLES.byDataset;
+
+    // temp patch to hide layers that are in development
+    var enableRasterTileLayer = getApplicationConfig().enableRasterTileLayer;
+    var enableWMSLayer = getApplicationConfig().enableWMSLayer;
+    var enableFlowLayer = getApplicationConfig().enableFlowLayer;
+    var enableLayerGroups = getApplicationConfig().enableLayerGroups;
+    var filteredLayerClasses = useMemo(function () {
+      var filteredClasses = layerClasses;
+      if (!enableRasterTileLayer) {
+        var _filteredClasses = filteredClasses,
+          _rasterTile = _filteredClasses.rasterTile,
+          rest = _objectWithoutProperties(_filteredClasses, _excluded);
+        filteredClasses = rest;
+      }
+      if (!enableWMSLayer) {
+        var _filteredClasses2 = filteredClasses,
+          _wms = _filteredClasses2.wms,
+          _rest = _objectWithoutProperties(_filteredClasses2, _excluded2);
+        filteredClasses = _rest;
+      }
+      if (!enableFlowLayer) {
+        var _filteredClasses3 = filteredClasses,
+          _flow = _filteredClasses3.flow,
+          _rest2 = _objectWithoutProperties(_filteredClasses3, _excluded3);
+        filteredClasses = _rest2;
+      }
+      return filteredClasses;
+    }, [enableRasterTileLayer, enableWMSLayer, enableFlowLayer, layerClasses]);
+    return /*#__PURE__*/React.createElement("div", {
+      className: "layer-manager"
+    }, /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelViewListToggle, {
+      togglePanelListView: onTogglePanelListView,
+      mode: panelListView
+    })), /*#__PURE__*/React.createElement(DatasetSection, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: showDeleteDataset,
+      showDatasetList: !isSortByDatasetMode,
+      showAddDataModal: showAddDataModal
+    }), /*#__PURE__*/React.createElement(SidePanelDivider, null), /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelTitle, {
+      className: "layer-manager-title",
+      title: intl.formatMessage({
+        id: panelMetadata.label
+      })
+    }, enableLayerGroups ? /*#__PURE__*/React.createElement(PanelHeaderAction, {
+      className: "layer-group__create",
+      id: "new-layer-group",
+      onClick: onAddGroup,
+      IconComponent: Folder,
+      tooltip: "Create layer group"
+    }) : null, /*#__PURE__*/React.createElement(AddLayerButton, {
+      datasets: datasets,
+      onAdd: onAddLayer
+    }))), /*#__PURE__*/React.createElement(SidePanelSection, null, isSortByDatasetMode ? /*#__PURE__*/React.createElement(DatasetLayerGroup, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      layers: layers,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      layerOrder: layerOrder,
+      layerClasses: filteredLayerClasses,
+      uiStateActions: uiStateActions,
+      visStateActions: visStateActions,
+      mapStateActions: mapStateActions,
+      mapState: mapState,
+      showDeleteDataset: showDeleteDataset
+    }) : /*#__PURE__*/React.createElement(LayerList, {
+      layers: layers,
+      datasets: datasets,
+      layerOrder: layerOrder,
+      uiStateActions: uiStateActions,
+      visStateActions: visStateActions,
+      mapStateActions: mapStateActions,
+      mapState: mapState,
+      layerClasses: filteredLayerClasses
+    })), /*#__PURE__*/React.createElement(LayerBlendingSelector, {
+      layerBlending: layerBlending,
+      updateLayerBlending: visStateActions.updateLayerBlending,
+      intl: intl
+    }), /*#__PURE__*/React.createElement(OverlayBlendingSelector, {
+      overlayBlending: overlayBlending,
+      updateOverlayBlending: visStateActions.updateOverlayBlending,
+      intl: intl,
+      infoHelper: /*#__PURE__*/React.createElement(InfoHelper, {
+        id: "overlayBlending-description",
+        description: 'overlayBlending.description'
+      })
+    }));
+  };
+  return injectIntl(LayerManager);
+}
+export default LayerManagerFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","injectIntl","styled","FormattedMessage","LayerListFactory","DatasetLayerGroupFactory","PanelViewListToggleFactory","PanelTitleFactory","DatasetSectionFactory","AddLayerButtonFactory","ItemSelector","PanelLabel","SidePanelDivider","SidePanelSection","InfoHelperFactory","LAYER_BLENDINGS","OVERLAY_BLENDINGS","PANEL_VIEW_TOGGLES","getApplicationConfig","PanelHeaderActionFactory","Folder","LayerBlendingSelector","memo","_ref","layerBlending","updateLayerBlending","intl","className","labeledLayerBlendings","Object","keys","reduce","acc","current","_objectSpread","_defineProperty","formatMessage","id","label","onChange","blending","createElement","selectedItems","options","multiSelect","searchable","displayName","InfoHelperWrapper","div","_templateObject","_taggedTemplateLiteral","OverlayBlendingSelectorTitleRow","_templateObject2","OverlayBlendingSelector","_ref2","overlayBlending","updateOverlayBlending","infoHelper","labeledOverlayBlendings","LayerManagerFactory","deps","LayerList","DatasetLayerGroup","PanelViewListToggle","PanelTitle","DatasetSection","AddLayerButton","InfoHelper","PanelHeaderAction","LayerManager","_ref3","layers","datasets","layerOrder","panelListView","panelMetadata","layerClasses","showAddDataModal","_ref3$showDeleteDatas","showDeleteDataset","updateTableColor","showDatasetTable","removeDataset","uiStateActions","visStateActions","mapStateActions","mapState","addLayer","togglePanelListView","onAddLayer","dataset","undefined","onAddGroup","addLayerGroup","onTogglePanelListView","listView","panelId","isSortByDatasetMode","byDataset","enableRasterTileLayer","enableWMSLayer","enableFlowLayer","enableLayerGroups","filteredLayerClasses","filteredClasses","_filteredClasses","_rasterTile","rasterTile","rest","_objectWithoutProperties","_excluded","_filteredClasses2","_wms","wms","_excluded2","_filteredClasses3","_flow","flow","_excluded3","mode","showDatasetList","title","onClick","IconComponent","tooltip","onAdd","description"],"sources":["../../../src/side-panel/layer-manager.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo} from 'react';\n\nimport {injectIntl, WrappedComponentProps} from 'react-intl';\nimport styled from 'styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\n\nimport LayerListFactory from './layer-panel/layer-list';\nimport DatasetLayerGroupFactory from './layer-panel/dataset-layer-group';\nimport PanelViewListToggleFactory from './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';\nimport InfoHelperFactory from '../common/info-helper';\n\nimport {LAYER_BLENDINGS, OVERLAY_BLENDINGS, PANEL_VIEW_TOGGLES} from '@kepler.gl/constants';\nimport {Layer, LayerClassesType} from '@kepler.gl/layers';\nimport {UIStateActions, VisStateActions, MapStateActions, ActionHandler} from '@kepler.gl/actions';\nimport {SidePanelItem} from '../types';\nimport {MapState, PanelListView, LayerOrder} from '@kepler.gl/types';\nimport {Datasets} from '@kepler.gl/table';\nimport {getApplicationConfig} from '@kepler.gl/utils';\nimport PanelHeaderActionFactory from './panel-header-action';\nimport {Folder} from '../common/icons';\n\ntype LayerBlendingSelectorProps = {\n  layerBlending: string;\n  updateLayerBlending: ActionHandler<typeof VisStateActions.updateLayerBlending>;\n  className?: string;\n} & WrappedComponentProps;\n\ntype OverlayBlendingSelectorProps = {\n  overlayBlending: string;\n  updateOverlayBlending: ActionHandler<typeof VisStateActions.updateOverlayBlending>;\n  infoHelper: React.ReactNode;\n} & WrappedComponentProps;\n\ntype LayerManagerProps = {\n  datasets: Datasets;\n  layers: Layer[];\n  layerOrder: LayerOrder;\n  layerClasses: LayerClassesType;\n  layerBlending: string;\n  overlayBlending: string;\n  uiStateActions: typeof UIStateActions;\n  visStateActions: typeof VisStateActions;\n  mapStateActions: typeof MapStateActions;\n  mapState?: MapState;\n  showAddDataModal: () => void;\n  removeDataset: ActionHandler<typeof UIStateActions.openDeleteModal>;\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  panelListView: PanelListView;\n  panelMetadata: SidePanelItem;\n  showDeleteDataset?: boolean;\n} & WrappedComponentProps;\n\nexport const LayerBlendingSelector = React.memo(\n  ({layerBlending, updateLayerBlending, intl, className}: 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(\n      blending => updateLayerBlending(labeledLayerBlendings[blending]),\n      [updateLayerBlending, labeledLayerBlendings]\n    );\n\n    return (\n      <SidePanelSection className={className}>\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\nconst InfoHelperWrapper = styled.div`\n  float: right;\n`;\n\nconst OverlayBlendingSelectorTitleRow = styled.div`\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n`;\n\nconst OverlayBlendingSelector = React.memo(\n  ({overlayBlending, updateOverlayBlending, intl, infoHelper}: OverlayBlendingSelectorProps) => {\n    const labeledOverlayBlendings = Object.keys(OVERLAY_BLENDINGS).reduce(\n      (acc, current) => ({\n        ...acc,\n        [intl.formatMessage({id: OVERLAY_BLENDINGS[current].label})]: current\n      }),\n      {}\n    );\n\n    const onChange = useCallback(\n      blending => updateOverlayBlending(labeledOverlayBlendings[blending]),\n      [updateOverlayBlending, labeledOverlayBlendings]\n    );\n\n    return (\n      <SidePanelSection>\n        <OverlayBlendingSelectorTitleRow>\n          <PanelLabel>\n            <FormattedMessage id=\"overlayBlending.title\" />\n          </PanelLabel>\n          <InfoHelperWrapper>{infoHelper}</InfoHelperWrapper>\n        </OverlayBlendingSelectorTitleRow>\n        <ItemSelector\n          selectedItems={intl.formatMessage({id: OVERLAY_BLENDINGS[overlayBlending].label})}\n          options={Object.keys(labeledOverlayBlendings)}\n          multiSelect={false}\n          searchable={false}\n          onChange={onChange}\n        />\n      </SidePanelSection>\n    );\n  }\n);\nOverlayBlendingSelector.displayName = 'OverlayBlendingSelector';\n\nLayerManagerFactory.deps = [\n  LayerListFactory,\n  DatasetLayerGroupFactory,\n  PanelViewListToggleFactory,\n  PanelTitleFactory,\n  DatasetSectionFactory,\n  AddLayerButtonFactory,\n  InfoHelperFactory,\n  PanelHeaderActionFactory\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  InfoHelper: ReturnType<typeof InfoHelperFactory>,\n  PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>\n) {\n  const LayerManager: React.FC<LayerManagerProps> = ({\n    layers,\n    datasets,\n    intl,\n    layerOrder,\n    panelListView,\n    panelMetadata,\n    layerClasses,\n    layerBlending,\n    overlayBlending,\n    showAddDataModal,\n    showDeleteDataset = true,\n    updateTableColor,\n    showDatasetTable,\n    removeDataset,\n    uiStateActions,\n    visStateActions,\n    mapStateActions,\n    mapState\n  }) => {\n    const {addLayer} = visStateActions;\n    const {togglePanelListView} = uiStateActions;\n    const onAddLayer = useCallback(\n      (dataset: string) => {\n        addLayer(undefined, dataset);\n      },\n      [addLayer]\n    );\n\n    const onAddGroup = useCallback(() => {\n      visStateActions.addLayerGroup({});\n    }, [visStateActions]);\n\n    const onTogglePanelListView = useCallback(\n      (listView: string) => {\n        togglePanelListView({panelId: 'layer', listView});\n      },\n      [togglePanelListView]\n    );\n\n    const isSortByDatasetMode = panelListView === PANEL_VIEW_TOGGLES.byDataset;\n\n    // temp patch to hide layers that are in development\n    const enableRasterTileLayer = getApplicationConfig().enableRasterTileLayer;\n    const enableWMSLayer = getApplicationConfig().enableWMSLayer;\n    const enableFlowLayer = getApplicationConfig().enableFlowLayer;\n    const enableLayerGroups = getApplicationConfig().enableLayerGroups;\n\n    const filteredLayerClasses = useMemo(() => {\n      let filteredClasses = layerClasses;\n      if (!enableRasterTileLayer) {\n        const {rasterTile: _rasterTile, ...rest} = filteredClasses;\n        filteredClasses = rest as LayerClassesType;\n      }\n      if (!enableWMSLayer) {\n        const {wms: _wms, ...rest} = filteredClasses;\n        filteredClasses = rest as LayerClassesType;\n      }\n      if (!enableFlowLayer) {\n        const {flow: _flow, ...rest} = filteredClasses;\n        filteredClasses = rest as LayerClassesType;\n      }\n      return filteredClasses as LayerClassesType;\n    }, [enableRasterTileLayer, enableWMSLayer, enableFlowLayer, layerClasses]);\n\n    return (\n      <div className=\"layer-manager\">\n        <SidePanelSection>\n          <PanelViewListToggle togglePanelListView={onTogglePanelListView} mode={panelListView} />\n        </SidePanelSection>\n        <DatasetSection\n          datasets={datasets}\n          showDatasetTable={showDatasetTable}\n          updateTableColor={updateTableColor}\n          removeDataset={removeDataset}\n          showDeleteDataset={showDeleteDataset}\n          showDatasetList={!isSortByDatasetMode}\n          showAddDataModal={showAddDataModal}\n        />\n        <SidePanelDivider />\n        <SidePanelSection>\n          <PanelTitle\n            className=\"layer-manager-title\"\n            title={intl.formatMessage({id: panelMetadata.label})}\n          >\n            {enableLayerGroups ? (\n              <PanelHeaderAction\n                className=\"layer-group__create\"\n                id=\"new-layer-group\"\n                onClick={onAddGroup}\n                IconComponent={Folder}\n                tooltip=\"Create layer group\"\n              />\n            ) : null}\n            <AddLayerButton datasets={datasets} onAdd={onAddLayer} />\n          </PanelTitle>\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={filteredLayerClasses}\n              uiStateActions={uiStateActions}\n              visStateActions={visStateActions}\n              mapStateActions={mapStateActions}\n              mapState={mapState}\n              showDeleteDataset={showDeleteDataset}\n            />\n          ) : (\n            <LayerList\n              layers={layers}\n              datasets={datasets}\n              layerOrder={layerOrder}\n              uiStateActions={uiStateActions}\n              visStateActions={visStateActions}\n              mapStateActions={mapStateActions}\n              mapState={mapState}\n              layerClasses={filteredLayerClasses}\n            />\n          )}\n        </SidePanelSection>\n        <LayerBlendingSelector\n          layerBlending={layerBlending}\n          updateLayerBlending={visStateActions.updateLayerBlending}\n          intl={intl}\n        />\n        <OverlayBlendingSelector\n          overlayBlending={overlayBlending}\n          updateOverlayBlending={visStateActions.updateOverlayBlending}\n          intl={intl}\n          infoHelper={\n            <InfoHelper\n              id={`overlayBlending-description`}\n              description={'overlayBlending.description'}\n            />\n          }\n        />\n      </div>\n    );\n  };\n\n  return injectIntl(LayerManager);\n}\n\nexport default LayerManagerFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import AddByDatasetButton from '../add-by-dataset-button';
+function AddLayerButtonFactory() {
+  var AddLayerButton = function AddLayerButton(_ref) {
+    var datasets = _ref.datasets,
+      onAdd = _ref.onAdd;
+    return /*#__PURE__*/React.createElement(AddByDatasetButton, {
+      datasets: datasets,
+      className: "add-layer-button",
+      onAdd: onAdd,
+      buttonIntlId: "layerManager.addLayer"
+    });
+  };
+  return AddLayerButton;
+}
+export default AddLayerButtonFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkFkZEJ5RGF0YXNldEJ1dHRvbiIsIkFkZExheWVyQnV0dG9uRmFjdG9yeSIsIkFkZExheWVyQnV0dG9uIiwiX3JlZiIsImRhdGFzZXRzIiwib25BZGQiLCJjcmVhdGVFbGVtZW50IiwiY2xhc3NOYW1lIiwiYnV0dG9uSW50bElkIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NpZGUtcGFuZWwvbGF5ZXItcGFuZWwvYWRkLWxheWVyLWJ1dHRvbi50c3giXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCBBZGRCeURhdGFzZXRCdXR0b24gZnJvbSAnLi4vYWRkLWJ5LWRhdGFzZXQtYnV0dG9uJztcbmltcG9ydCB7RGF0YXNldHN9IGZyb20gJ0BrZXBsZXIuZ2wvdGFibGUnO1xuXG5leHBvcnQgdHlwZSBBZGRMYXllckJ1dHRvblByb3BzID0ge1xuICBkYXRhc2V0czogRGF0YXNldHM7XG4gIG9uQWRkOiAoZGF0YUlkOiBzdHJpbmcpID0+IHZvaWQ7XG59O1xuXG5mdW5jdGlvbiBBZGRMYXllckJ1dHRvbkZhY3RvcnkoKSB7XG4gIGNvbnN0IEFkZExheWVyQnV0dG9uOiBSZWFjdC5GQzxBZGRMYXllckJ1dHRvblByb3BzPiA9ICh7ZGF0YXNldHMsIG9uQWRkfSkgPT4ge1xuICAgIHJldHVybiAoXG4gICAgICA8QWRkQnlEYXRhc2V0QnV0dG9uXG4gICAgICAgIGRhdGFzZXRzPXtkYXRhc2V0c31cbiAgICAgICAgY2xhc3NOYW1lPVwiYWRkLWxheWVyLWJ1dHRvblwiXG4gICAgICAgIG9uQWRkPXtvbkFkZH1cbiAgICAgICAgYnV0dG9uSW50bElkPVwibGF5ZXJNYW5hZ2VyLmFkZExheWVyXCJcbiAgICAgIC8+XG4gICAgKTtcbiAgfTtcblxuICByZXR1cm4gQWRkTGF5ZXJCdXR0b247XG59XG5leHBvcnQgZGVmYXVsdCBBZGRMYXllckJ1dHRvbkZhY3Rvcnk7XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7O0FBRUEsT0FBT0EsS0FBSyxNQUFNLE9BQU87QUFDekIsT0FBT0Msa0JBQWtCLE1BQU0sMEJBQTBCO0FBUXpELFNBQVNDLHFCQUFxQkEsQ0FBQSxFQUFHO0VBQy9CLElBQU1DLGNBQTZDLEdBQUcsU0FBaERBLGNBQTZDQSxDQUFBQyxJQUFBLEVBQTBCO0lBQUEsSUFBckJDLFFBQVEsR0FBQUQsSUFBQSxDQUFSQyxRQUFRO01BQUVDLEtBQUssR0FBQUYsSUFBQSxDQUFMRSxLQUFLO0lBQ3JFLG9CQUNFTixLQUFBLENBQUFPLGFBQUEsQ0FBQ04sa0JBQWtCO01BQ2pCSSxRQUFRLEVBQUVBLFFBQVM7TUFDbkJHLFNBQVMsRUFBQyxrQkFBa0I7TUFDNUJGLEtBQUssRUFBRUEsS0FBTTtNQUNiRyxZQUFZLEVBQUM7SUFBdUIsQ0FDckMsQ0FBQztFQUVOLENBQUM7RUFFRCxPQUFPTixjQUFjO0FBQ3ZCO0FBQ0EsZUFBZUQscUJBQXFCIiwiaWdub3JlTGlzdCI6W119

package/dist/esm/side-panel/layer-panel/aggr-scale-selector.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import DimensionScaleSelectorFactory from './dimension-scale-selector';
+AggrScaleSelectorFactory.deps = [DimensionScaleSelectorFactory];
+export function AggrScaleSelectorFactory(DimensionScaleSelector) {
+  var AggrScaleSelector = function AggrScaleSelector(_ref) {
+    var channel = _ref.channel,
+      dataset = _ref.dataset,
+      layer = _ref.layer,
+      onChange = _ref.onChange,
+      setColorUI = _ref.setColorUI,
+      label = _ref.label;
+    var key = channel.key;
+    var scaleOptions = layer.getScaleOptions(key);
+    return Array.isArray(scaleOptions) && scaleOptions.length > 1 ? /*#__PURE__*/React.createElement(DimensionScaleSelector, {
+      dataset: dataset,
+      layer: layer,
+      channel: channel,
+      label: label || "".concat(key, " Scale"),
+      onChange: onChange,
+      setColorUI: setColorUI
+    }) : null;
+  };
+  return AggrScaleSelector;
+}
+export default AggrScaleSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/side-panel/layer-panel/channel-by-value-selector.js

@@ -0,0 +1,61 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback } from 'react';
+import { CHANNEL_SCALE_SUPPORTED_FIELDS } from '@kepler.gl/constants';
+import DimensionScaleSelectorFactory from './dimension-scale-selector';
+import VisConfigByFieldSelectorFactory from './vis-config-by-field-selector';
+ChannelByValueSelectorFactory.deps = [VisConfigByFieldSelectorFactory, DimensionScaleSelectorFactory];
+export function ChannelByValueSelectorFactory(VisConfigByFieldSelector, DimensionScaleSelector) {
+  var ChannelByValueSelector = function ChannelByValueSelector(_ref) {
+    var layer = _ref.layer,
+      channel = _ref.channel,
+      onChange = _ref.onChange,
+      fields = _ref.fields,
+      dataset = _ref.dataset,
+      description = _ref.description,
+      setColorUI = _ref.setColorUI,
+      disabled = _ref.disabled;
+    var channelScaleType = channel.channelScaleType,
+      field = channel.field,
+      key = channel.key,
+      property = channel.property,
+      scale = channel.scale,
+      defaultMeasure = channel.defaultMeasure,
+      supportedFieldTypes = channel.supportedFieldTypes;
+    var channelSupportedFieldTypes = supportedFieldTypes || CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];
+    var supportedFields = fields.filter(function (_ref2) {
+      var type = _ref2.type;
+      return channelSupportedFieldTypes.includes(type);
+    });
+    var showScale = !layer.isAggregated && layer.config[scale] && layer.config[field];
+    var defaultDescription = 'layerConfiguration.defaultDescription';
+    var updateField = useCallback(function (val) {
+      onChange(_defineProperty({}, field, val), key);
+    }, [onChange, field, key]);
+    return /*#__PURE__*/React.createElement("div", {
+      className: "channel-by-value-selector"
+    }, /*#__PURE__*/React.createElement(VisConfigByFieldSelector, {
+      description: description || defaultDescription,
+      fields: supportedFields,
+      id: layer.id,
+      key: "".concat(key, "-channel-selector"),
+      property: property,
+      disabled: disabled,
+      placeholder: defaultMeasure || 'placeholder.selectField',
+      selectedField: layer.config[field],
+      updateField: updateField
+    }), showScale && !disabled ? /*#__PURE__*/React.createElement(DimensionScaleSelector, {
+      layer: layer,
+      channel: channel,
+      dataset: dataset,
+      label: "".concat(property, " scale"),
+      setColorUI: setColorUI,
+      onChange: onChange
+    }) : null);
+  };
+  return ChannelByValueSelector;
+}
+export default ChannelByValueSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","CHANNEL_SCALE_SUPPORTED_FIELDS","DimensionScaleSelectorFactory","VisConfigByFieldSelectorFactory","ChannelByValueSelectorFactory","deps","VisConfigByFieldSelector","DimensionScaleSelector","ChannelByValueSelector","_ref","layer","channel","onChange","fields","dataset","description","setColorUI","disabled","channelScaleType","field","key","property","scale","defaultMeasure","supportedFieldTypes","channelSupportedFieldTypes","supportedFields","filter","_ref2","type","includes","showScale","isAggregated","config","defaultDescription","updateField","val","_defineProperty","createElement","className","id","concat","placeholder","selectedField","label"],"sources":["../../../../src/side-panel/layer-panel/channel-by-value-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback} from 'react';\n\nimport {CHANNEL_SCALE_SUPPORTED_FIELDS} from '@kepler.gl/constants';\nimport {Layer, VisualChannel} from '@kepler.gl/layers';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {ColorUI, Field, LayerVisConfig, NestedPartial} from '@kepler.gl/types';\n\nimport DimensionScaleSelectorFactory from './dimension-scale-selector';\nimport VisConfigByFieldSelectorFactory from './vis-config-by-field-selector';\n\nexport type ChannelByValueSelectorProps = {\n  layer: Layer;\n  channel: VisualChannel;\n  onChange: (\n    newConfig: {[key: string]: Field | null | string},\n    key: string,\n    newVisConfig?: Partial<LayerVisConfig>\n  ) => void;\n  fields: Field[];\n  dataset: KeplerTable | undefined;\n  description?: string;\n  setColorUI: (prop: string, newConfig: NestedPartial<ColorUI>) => void;\n  updateLayerVisConfig: (newConfig: Partial<LayerVisConfig>) => void;\n  disabled?: boolean;\n};\n\nChannelByValueSelectorFactory.deps = [\n  VisConfigByFieldSelectorFactory,\n  DimensionScaleSelectorFactory\n];\n\nexport function ChannelByValueSelectorFactory(\n  VisConfigByFieldSelector: ReturnType<typeof VisConfigByFieldSelectorFactory>,\n  DimensionScaleSelector: ReturnType<typeof DimensionScaleSelectorFactory>\n): React.FC<ChannelByValueSelectorProps> {\n  const ChannelByValueSelector: React.FC<ChannelByValueSelectorProps> = ({\n    layer,\n    channel,\n    onChange,\n    fields,\n    dataset,\n    description,\n    setColorUI,\n    disabled\n  }) => {\n    const {channelScaleType, field, key, property, scale, defaultMeasure, supportedFieldTypes} =\n      channel;\n    const channelSupportedFieldTypes =\n      supportedFieldTypes || CHANNEL_SCALE_SUPPORTED_FIELDS[channelScaleType];\n    const supportedFields = fields.filter(({type}) => channelSupportedFieldTypes.includes(type));\n    const showScale = !layer.isAggregated && layer.config[scale] && layer.config[field];\n    const defaultDescription = 'layerConfiguration.defaultDescription';\n    const updateField = useCallback(\n      val => {\n        onChange({[field]: val}, key);\n      },\n      [onChange, field, key]\n    );\n\n    return (\n      <div className=\"channel-by-value-selector\">\n        <VisConfigByFieldSelector\n          description={description || defaultDescription}\n          fields={supportedFields}\n          id={layer.id}\n          key={`${key}-channel-selector`}\n          property={property}\n          disabled={disabled}\n          placeholder={defaultMeasure || 'placeholder.selectField'}\n          selectedField={layer.config[field]}\n          updateField={updateField}\n        />\n        {showScale && !disabled ? (\n          <DimensionScaleSelector\n            layer={layer}\n            channel={channel}\n            dataset={dataset}\n            label={`${property} scale`}\n            setColorUI={setColorUI}\n            onChange={onChange}\n          />\n        ) : null}\n      </div>\n    );\n  };\n\n  return ChannelByValueSelector;\n}\n\nexport default ChannelByValueSelectorFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/side-panel/layer-panel/color-breaks-panel.js

@@ -0,0 +1,186 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { toArray } from '@kepler.gl/common-utils';
+import { SCALE_TYPES } from '@kepler.gl/constants';
+import { colorBreaksToColorMap, colorMapToColorBreaks, isNumericColorBreaks as notOrdinalColorBreaks } from '@kepler.gl/utils';
+import React, { useCallback, useMemo, useEffect } from 'react';
+import styled from 'styled-components';
+import ColumnStatsChartFactory from '../../common/column-stats-chart';
+import { Edit } from '../../common/icons';
+import { Button } from '../../common/styled-components';
+import CustomPaletteFactory, { ColorPaletteItem, ColorSwatch, EditableColorRange, CategoricalSelector } from './custom-palette';
+var StyledColorBreaksPanel = styled.div.attrs({
+  className: 'styled-color-breaks-panel'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  margin-bottom: 10px;\n"])));
+var StyledColorBreaksDisplay = styled.div.attrs({
+  className: 'styled-color-breaks-display'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  padding: 8px 12px 0 12px;\n"])));
+var ColorBreaksPanelWrapper = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral([""])));
+export var EditButton = function EditButton(_ref) {
+  var onClickEdit = _ref.onClickEdit;
+  return /*#__PURE__*/React.createElement(Button, {
+    className: "editp__button",
+    link: true,
+    onClick: onClickEdit
+  }, /*#__PURE__*/React.createElement(Edit, {
+    height: "16px"
+  }), "Edit");
+};
+export var ColorBreaksDisplay = function ColorBreaksDisplay(_ref2) {
+  var currentBreaks = _ref2.currentBreaks,
+    onEdit = _ref2.onEdit;
+  if (!notOrdinalColorBreaks(currentBreaks)) {
+    // don't display color breaks for ordinal breaks, user can change it in custom breaks
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(StyledColorBreaksDisplay, null, onEdit ? /*#__PURE__*/React.createElement(EditButton, {
+    onClickEdit: onEdit
+  }) : null, currentBreaks.map(function (item, index) {
+    return /*#__PURE__*/React.createElement(ColorPaletteItem, {
+      className: "disabled",
+      key: index
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "custom-palette-input__left"
+    }, /*#__PURE__*/React.createElement(ColorSwatch, {
+      color: item.data
+    }), /*#__PURE__*/React.createElement(EditableColorRange, {
+      item: item,
+      isLast: index === currentBreaks.length - 1,
+      index: index,
+      editable: false
+    })));
+  }));
+};
+export var CategoricalColorDisplay = function CategoricalColorDisplay(_ref3) {
+  var colorMap = _ref3.colorMap,
+    onEdit = _ref3.onEdit;
+  return /*#__PURE__*/React.createElement(StyledColorBreaksDisplay, null, onEdit ? /*#__PURE__*/React.createElement(EditButton, {
+    onClickEdit: onEdit
+  }) : null, colorMap === null || colorMap === void 0 ? void 0 : colorMap.map(function (cm, index) {
+    return /*#__PURE__*/React.createElement(ColorPaletteItem, {
+      className: "disabled",
+      key: index
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "custom-palette-input__left"
+    }, /*#__PURE__*/React.createElement(ColorSwatch, {
+      color: cm[1]
+    }), /*#__PURE__*/React.createElement(CategoricalSelector, {
+      index: index,
+      selectedValues: toArray(cm[0]),
+      allValues: [],
+      editable: false
+    })));
+  }));
+};
+ColorBreaksPanelFactory.deps = [CustomPaletteFactory, ColumnStatsChartFactory];
+function ColorBreaksPanelFactory(CustomPalette, ColumnStatsChart) {
+  // eslint-disable-next-line complexity
+  var ColorBreaksPanel = function ColorBreaksPanel(_ref4) {
+    var _customPalette$name;
+    var colorBreaks = _ref4.colorBreaks,
+      colorUIConfig = _ref4.colorUIConfig,
+      dataset = _ref4.dataset,
+      colorField = _ref4.colorField,
+      isCustomBreaks = _ref4.isCustomBreaks,
+      allBins = _ref4.allBins,
+      filteredBins = _ref4.filteredBins,
+      isFiltered = _ref4.isFiltered,
+      histogramDomain = _ref4.histogramDomain,
+      ordinalDomain = _ref4.ordinalDomain,
+      setColorUI = _ref4.setColorUI,
+      onScaleChange = _ref4.onScaleChange,
+      onApply = _ref4.onApply,
+      onCancel = _ref4.onCancel;
+    var customPalette = colorUIConfig.customPalette,
+      showSketcher = colorUIConfig.showSketcher,
+      colorRangeConfig = colorUIConfig.colorRangeConfig;
+    var isEditingCustomBreaks = Boolean(colorRangeConfig.customBreaks);
+    var currentBreaks = useMemo(function () {
+      return isEditingCustomBreaks ? colorMapToColorBreaks(customPalette.colorMap) : colorBreaks;
+    }, [customPalette.colorMap, isEditingCustomBreaks, colorBreaks]);
+
+    // Update layers on editing custom breaks
+    useEffect(function () {
+      var _ref5 = customPalette || {},
+        type = _ref5.type;
+      if (isEditingCustomBreaks && (type === SCALE_TYPES.customOrdinal || type === SCALE_TYPES.custom)) {
+        onScaleChange(type, customPalette);
+      }
+    }, [isEditingCustomBreaks, customPalette, onScaleChange]);
+    var onClickEditCustomBreaks = useCallback(function () {
+      setColorUI({
+        colorRangeConfig: {
+          customBreaks: true
+        }
+      });
+    }, [setColorUI]);
+    var onCilckCancel = useCallback(function () {
+      setColorUI({
+        showSketcher: false,
+        colorRangeConfig: {
+          customBreaks: false
+        }
+      });
+      onCancel();
+    }, [setColorUI, onCancel]);
+    var onColumnStatsChartChanged = useCallback(function (newColorBreaks) {
+      var newColors = newColorBreaks.map(function (cb) {
+        return cb.data;
+      });
+      var newColorMap = colorBreaksToColorMap(newColorBreaks);
+      var newCustomPalette = _objectSpread(_objectSpread({}, customPalette), {}, {
+        colorMap: newColorMap,
+        colors: newColors
+      });
+
+      // update custom pallette editor
+      if (!isEditingCustomBreaks) {
+        setColorUI({
+          colorRangeConfig: {
+            customBreaks: true
+          },
+          customPalette: newCustomPalette
+        });
+      } else {
+        setColorUI({
+          customPalette: newCustomPalette
+        });
+      }
+
+      // trigger the map to re-render using newCustomPalette
+      onScaleChange(SCALE_TYPES.custom, newCustomPalette);
+    }, [setColorUI, customPalette, isEditingCustomBreaks, onScaleChange]);
+    return /*#__PURE__*/React.createElement(ColorBreaksPanelWrapper, null, dataset && allBins.length > 1 && notOrdinalColorBreaks(colorBreaks) ? /*#__PURE__*/React.createElement(ColumnStatsChart, {
+      colorField: colorField,
+      dataset: dataset,
+      colorBreaks: currentBreaks,
+      allBins: allBins,
+      filteredBins: filteredBins,
+      isFiltered: isFiltered,
+      histogramDomain: histogramDomain,
+      onChangedUpdater: onColumnStatsChartChanged
+    }) : null, /*#__PURE__*/React.createElement(StyledColorBreaksPanel, null, isEditingCustomBreaks ? /*#__PURE__*/React.createElement(CustomPalette, {
+      ordinalDomain: ordinalDomain,
+      customPalette: customPalette,
+      setColorPaletteUI: setColorUI,
+      showSketcher: showSketcher,
+      onApply: onApply,
+      onCancel: onCilckCancel
+    }) : currentBreaks && allBins.length > 1 && notOrdinalColorBreaks(colorBreaks) ? /*#__PURE__*/React.createElement(ColorBreaksDisplay, {
+      currentBreaks: currentBreaks,
+      onEdit: isCustomBreaks ? onClickEditCustomBreaks : null
+    }) : (isCustomBreaks || customPalette.type === SCALE_TYPES.customOrdinal) && customPalette.colorMap && (_customPalette$name = customPalette.name) !== null && _customPalette$name !== void 0 && _customPalette$name.endsWith(colorField.name) ? /*#__PURE__*/React.createElement(CategoricalColorDisplay, {
+      colorMap: customPalette.colorMap,
+      onEdit: isCustomBreaks ? onClickEditCustomBreaks : null
+    }) : null));
+  };
+  return /*#__PURE__*/React.memo(ColorBreaksPanel);
+}
+export default ColorBreaksPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["toArray","SCALE_TYPES","colorBreaksToColorMap","colorMapToColorBreaks","isNumericColorBreaks","notOrdinalColorBreaks","React","useCallback","useMemo","useEffect","styled","ColumnStatsChartFactory","Edit","Button","CustomPaletteFactory","ColorPaletteItem","ColorSwatch","EditableColorRange","CategoricalSelector","StyledColorBreaksPanel","div","attrs","className","_templateObject","_taggedTemplateLiteral","StyledColorBreaksDisplay","_templateObject2","ColorBreaksPanelWrapper","_templateObject3","EditButton","_ref","onClickEdit","createElement","link","onClick","height","ColorBreaksDisplay","_ref2","currentBreaks","onEdit","map","item","index","key","color","data","isLast","length","editable","CategoricalColorDisplay","_ref3","colorMap","cm","selectedValues","allValues","ColorBreaksPanelFactory","deps","CustomPalette","ColumnStatsChart","ColorBreaksPanel","_ref4","_customPalette$name","colorBreaks","colorUIConfig","dataset","colorField","isCustomBreaks","allBins","filteredBins","isFiltered","histogramDomain","ordinalDomain","setColorUI","onScaleChange","onApply","onCancel","customPalette","showSketcher","colorRangeConfig","isEditingCustomBreaks","Boolean","customBreaks","_ref5","type","customOrdinal","custom","onClickEditCustomBreaks","onCilckCancel","onColumnStatsChartChanged","newColorBreaks","newColors","cb","newColorMap","newCustomPalette","_objectSpread","colors","onChangedUpdater","setColorPaletteUI","name","endsWith","memo"],"sources":["../../../../src/side-panel/layer-panel/color-breaks-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {toArray} from '@kepler.gl/common-utils';\nimport {SCALE_TYPES} from '@kepler.gl/constants';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {Bin, ColorMap, ColorUI, Field} from '@kepler.gl/types';\nimport {\n  ColorBreak,\n  ColorBreakOrdinal,\n  colorBreaksToColorMap,\n  colorMapToColorBreaks,\n  isNumericColorBreaks as notOrdinalColorBreaks\n} from '@kepler.gl/utils';\nimport React, {useCallback, useMemo, useEffect} from 'react';\nimport styled from 'styled-components';\nimport ColumnStatsChartFactory from '../../common/column-stats-chart';\nimport {Edit} from '../../common/icons';\nimport {Button} from '../../common/styled-components';\nimport CustomPaletteFactory, {\n  ColorPaletteItem,\n  ColorSwatch,\n  EditableColorRange,\n  CategoricalSelector,\n  SetColorUIFunc\n} from './custom-palette';\n\nconst StyledColorBreaksPanel = styled.div.attrs({\n  className: 'styled-color-breaks-panel'\n})`\n  margin-bottom: 10px;\n`;\n\nconst StyledColorBreaksDisplay = styled.div.attrs({\n  className: 'styled-color-breaks-display'\n})`\n  padding: 8px 12px 0 12px;\n`;\n\nconst ColorBreaksPanelWrapper = styled.div``;\n\ntype EditButtonProps = {onClickEdit: () => void};\n\nexport const EditButton: React.FC<EditButtonProps> = ({onClickEdit}) => (\n  <Button className=\"editp__button\" link onClick={onClickEdit}>\n    <Edit height=\"16px\" />\n    Edit\n  </Button>\n);\n\nexport type ColorBreaksDisplayProps = {\n  currentBreaks?: ColorBreak[] | ColorBreakOrdinal[] | null;\n  onEdit: (() => void) | null;\n};\n\nexport const ColorBreaksDisplay: React.FC<ColorBreaksDisplayProps> = ({currentBreaks, onEdit}) => {\n  if (!notOrdinalColorBreaks(currentBreaks)) {\n    // don't display color breaks for ordinal breaks, user can change it in custom breaks\n    return null;\n  }\n  return (\n    <StyledColorBreaksDisplay>\n      {onEdit ? <EditButton onClickEdit={onEdit} /> : null}\n      {currentBreaks.map((item, index) => (\n        <ColorPaletteItem className=\"disabled\" key={index}>\n          <div className=\"custom-palette-input__left\">\n            <ColorSwatch color={item.data} />\n            <EditableColorRange\n              item={item}\n              isLast={index === currentBreaks.length - 1}\n              index={index}\n              editable={false}\n            />\n          </div>\n        </ColorPaletteItem>\n      ))}\n    </StyledColorBreaksDisplay>\n  );\n};\n\nexport type CategoricalColorDisplayProps = {\n  colorMap?: ColorMap;\n  onEdit: (() => void) | null;\n};\n\nexport const CategoricalColorDisplay: React.FC<CategoricalColorDisplayProps> = ({\n  colorMap,\n  onEdit\n}: CategoricalColorDisplayProps) => {\n  return (\n    <StyledColorBreaksDisplay>\n      {onEdit ? <EditButton onClickEdit={onEdit} /> : null}\n      {colorMap?.map((cm, index) => (\n        <ColorPaletteItem className=\"disabled\" key={index}>\n          <div className=\"custom-palette-input__left\">\n            <ColorSwatch color={cm[1]} />\n            <CategoricalSelector\n              index={index}\n              selectedValues={toArray(cm[0])}\n              allValues={[]}\n              editable={false}\n            />\n          </div>\n        </ColorPaletteItem>\n      ))}\n    </StyledColorBreaksDisplay>\n  );\n};\n\nexport type ColorBreaksPanelProps = {\n  colorBreaks: ColorBreak[] | ColorBreakOrdinal[] | null;\n  colorUIConfig: ColorUI;\n  dataset: KeplerTable | undefined;\n  colorField: Field;\n  isCustomBreaks: boolean;\n  allBins: Bin[];\n  filteredBins: Bin[];\n  isFiltered: boolean;\n  histogramDomain: number[];\n  ordinalDomain: number[] | string[];\n  setColorUI: SetColorUIFunc;\n  onScaleChange: (v: string, visConfg?: Record<string, any>) => void;\n  onApply: (e: React.MouseEvent) => void;\n  onCancel: () => void;\n};\n\nColorBreaksPanelFactory.deps = [CustomPaletteFactory, ColumnStatsChartFactory];\n\nfunction ColorBreaksPanelFactory(\n  CustomPalette: ReturnType<typeof CustomPaletteFactory>,\n  ColumnStatsChart: ReturnType<typeof ColumnStatsChartFactory>\n): React.FC<ColorBreaksPanelProps> {\n  // eslint-disable-next-line complexity\n  const ColorBreaksPanel: React.FC<ColorBreaksPanelProps> = ({\n    colorBreaks,\n    colorUIConfig,\n    dataset,\n    colorField,\n    isCustomBreaks,\n    allBins,\n    filteredBins,\n    isFiltered,\n    histogramDomain,\n    ordinalDomain,\n    setColorUI,\n    onScaleChange,\n    onApply,\n    onCancel\n  }) => {\n    const {customPalette, showSketcher, colorRangeConfig} = colorUIConfig;\n    const isEditingCustomBreaks = Boolean(colorRangeConfig.customBreaks);\n\n    const currentBreaks = useMemo(\n      () => (isEditingCustomBreaks ? colorMapToColorBreaks(customPalette.colorMap) : colorBreaks),\n      [customPalette.colorMap, isEditingCustomBreaks, colorBreaks]\n    );\n\n    // Update layers on editing custom breaks\n    useEffect(() => {\n      const {type} = customPalette || {};\n      if (\n        isEditingCustomBreaks &&\n        (type === SCALE_TYPES.customOrdinal || type === SCALE_TYPES.custom)\n      ) {\n        onScaleChange(type, customPalette);\n      }\n    }, [isEditingCustomBreaks, customPalette, onScaleChange]);\n\n    const onClickEditCustomBreaks = useCallback(() => {\n      setColorUI({\n        colorRangeConfig: {\n          customBreaks: true\n        }\n      });\n    }, [setColorUI]);\n\n    const onCilckCancel = useCallback(() => {\n      setColorUI({\n        showSketcher: false,\n        colorRangeConfig: {\n          customBreaks: false\n        }\n      });\n      onCancel();\n    }, [setColorUI, onCancel]);\n\n    const onColumnStatsChartChanged = useCallback(\n      newColorBreaks => {\n        const newColors = newColorBreaks.map(cb => cb.data);\n        const newColorMap = colorBreaksToColorMap(newColorBreaks);\n\n        const newCustomPalette = {\n          ...customPalette,\n          colorMap: newColorMap,\n          colors: newColors\n        };\n\n        // update custom pallette editor\n        if (!isEditingCustomBreaks) {\n          setColorUI({\n            colorRangeConfig: {\n              customBreaks: true\n            },\n            customPalette: newCustomPalette\n          });\n        } else {\n          setColorUI({customPalette: newCustomPalette});\n        }\n\n        // trigger the map to re-render using newCustomPalette\n        onScaleChange(SCALE_TYPES.custom, newCustomPalette);\n      },\n      [setColorUI, customPalette, isEditingCustomBreaks, onScaleChange]\n    );\n\n    return (\n      <ColorBreaksPanelWrapper>\n        {dataset && allBins.length > 1 && notOrdinalColorBreaks(colorBreaks) ? (\n          <ColumnStatsChart\n            colorField={colorField}\n            dataset={dataset}\n            colorBreaks={currentBreaks}\n            allBins={allBins}\n            filteredBins={filteredBins}\n            isFiltered={isFiltered}\n            histogramDomain={histogramDomain}\n            onChangedUpdater={onColumnStatsChartChanged}\n          />\n        ) : null}\n        <StyledColorBreaksPanel>\n          {isEditingCustomBreaks ? (\n            <CustomPalette\n              ordinalDomain={ordinalDomain}\n              customPalette={customPalette}\n              setColorPaletteUI={setColorUI}\n              showSketcher={showSketcher}\n              onApply={onApply}\n              onCancel={onCilckCancel}\n            />\n          ) : currentBreaks && allBins.length > 1 && notOrdinalColorBreaks(colorBreaks) ? (\n            <ColorBreaksDisplay\n              currentBreaks={currentBreaks}\n              onEdit={isCustomBreaks ? onClickEditCustomBreaks : null}\n            />\n          ) : (isCustomBreaks || customPalette.type === SCALE_TYPES.customOrdinal) &&\n            customPalette.colorMap &&\n            customPalette.name?.endsWith(colorField.name) ? (\n            <CategoricalColorDisplay\n              colorMap={customPalette.colorMap}\n              onEdit={isCustomBreaks ? onClickEditCustomBreaks : null}\n            />\n          ) : null}\n        </StyledColorBreaksPanel>\n      </ColorBreaksPanelWrapper>\n    );\n  };\n\n  return React.memo(ColorBreaksPanel);\n}\n\nexport default ColorBreaksPanelFactory;\n"],"mappings":"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","ignoreList":[]}