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

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

@@ -0,0 +1,77 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled, { withTheme } from 'styled-components';
+import { SketchPicker } from 'react-color';
+import { panelBackground } from '@kepler.gl/styles';
+
+// This was put in because 3rd party library react-color doesn't yet cater for customized color of child component <SketchField> which contains HEX/RGB input text box
+// Issue raised: https://github.com/casesandberg/react-color/issues/631
+
+var StyledPicker = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  .sketch-picker {\n    span {\n      color: ", " !important;\n      font-family: ", ";\n    }\n    input {\n      text-align: center;\n      font-family: ", ";\n      color: ", " !important;\n      border-color: ", " !important;\n      box-shadow: none !important;\n      background-color: ", " !important;\n\n      &:hover {\n        cursor: ", ";\n        background-color: ", ";\n        border-color: ", ";\n      }\n\n      &:active,\n      &:focus,\n      &.focus,\n      &.active {\n        outline: 0;\n        background-color: ", ";\n        border-color: ", ";\n        box-shadow: ", ";\n      }\n    }\n    label {\n      color: ", " !important;\n    }\n  }\n"])), function (props) {
+  return props.theme.labelColor;
+}, function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.fontFamily;
+}, function (props) {
+  return props.theme.inputColor;
+}, function (props) {
+  return props.theme.secondaryInputBgd;
+}, function (props) {
+  return props.theme.inputBgdHover;
+}, function (props) {
+  return props.type === 'number' || props.type === 'text' ? 'text' : 'pointer';
+}, function (props) {
+  return props.active ? props.theme.inputBgdActive : props.theme.inputBgdHover;
+}, function (props) {
+  return props.active ? props.theme.inputBorderActiveColor : props.theme.inputBorderHoverColor;
+}, function (props) {
+  return props.theme.inputBgdActive;
+}, function (props) {
+  return props.theme.inputBorderActiveColor;
+}, function (props) {
+  return props.theme.inputBoxShadowActive;
+}, function (props) {
+  return props.theme.subtextColor;
+});
+var PRESET_COLORS = [];
+var defaultProps = {
+  color: '#f00',
+  theme: {
+    panelBackground: panelBackground
+  },
+  onChange: function onChange() {
+    // no-op
+  }
+};
+
+// Note: When using SketchPicker, the parent component CustomPicker can be invoked as a function without props by ReactDOM.
+var CustomPicker = function CustomPicker() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultProps;
+  var color = props.color,
+    onChange = props.onChange,
+    theme = props.theme;
+  var pickerStyle = useMemo(function () {
+    return {
+      picker: {
+        width: '200px',
+        padding: '10px 10px 8px',
+        boxSizing: 'initial',
+        background: theme.panelBackground
+      }
+    };
+  }, [theme.panelBackground]);
+  return /*#__PURE__*/React.createElement(StyledPicker, null, /*#__PURE__*/React.createElement(SketchPicker, {
+    color: color,
+    onChange: onChange,
+    presetColors: PRESET_COLORS,
+    styles: pickerStyle,
+    disableAlpha: true
+  }));
+};
+export default withTheme(CustomPicker);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","styled","withTheme","SketchPicker","panelBackground","StyledPicker","div","_templateObject","_taggedTemplateLiteral","props","theme","labelColor","fontFamily","inputColor","secondaryInputBgd","inputBgdHover","type","active","inputBgdActive","inputBorderActiveColor","inputBorderHoverColor","inputBoxShadowActive","subtextColor","PRESET_COLORS","defaultProps","color","onChange","CustomPicker","arguments","length","undefined","pickerStyle","picker","width","padding","boxSizing","background","createElement","presetColors","styles","disableAlpha"],"sources":["../../../../src/side-panel/layer-panel/custom-picker.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\nimport styled, {withTheme} from 'styled-components';\nimport {SketchPicker, ColorChangeHandler} from 'react-color';\n\nimport {HexColor} from '@kepler.gl/types';\nimport {panelBackground} from '@kepler.gl/styles';\n\nimport {BaseComponentProps} from '../../types';\n\n// This was put in because 3rd party library react-color doesn't yet cater for customized color of child component <SketchField> which contains HEX/RGB input text box\n// Issue raised: https://github.com/casesandberg/react-color/issues/631\n\ntype StyledPickerProps = {\n  type?: string;\n  active?: boolean;\n} & BaseComponentProps;\n\nconst StyledPicker = styled.div<StyledPickerProps>`\n  .sketch-picker {\n    span {\n      color: ${props => props.theme.labelColor} !important;\n      font-family: ${props => props.theme.fontFamily};\n    }\n    input {\n      text-align: center;\n      font-family: ${props => props.theme.fontFamily};\n      color: ${props => props.theme.inputColor} !important;\n      border-color: ${props => props.theme.secondaryInputBgd} !important;\n      box-shadow: none !important;\n      background-color: ${props => props.theme.inputBgdHover} !important;\n\n      &:hover {\n        cursor: ${props => (props.type === 'number' || props.type === 'text' ? 'text' : 'pointer')};\n        background-color: ${props =>\n          props.active ? props.theme.inputBgdActive : props.theme.inputBgdHover};\n        border-color: ${props =>\n          props.active ? props.theme.inputBorderActiveColor : props.theme.inputBorderHoverColor};\n      }\n\n      &:active,\n      &:focus,\n      &.focus,\n      &.active {\n        outline: 0;\n        background-color: ${props => props.theme.inputBgdActive};\n        border-color: ${props => props.theme.inputBorderActiveColor};\n        box-shadow: ${props => props.theme.inputBoxShadowActive};\n      }\n    }\n    label {\n      color: ${props => props.theme.subtextColor} !important;\n    }\n  }\n`;\n\nconst PRESET_COLORS = [];\n\ntype CustomPickerProps = {\n  color: HexColor;\n  theme: {\n    panelBackground: string;\n  };\n  onChange: ColorChangeHandler;\n};\n\nconst defaultProps: CustomPickerProps = {\n  color: '#f00',\n  theme: {\n    panelBackground\n  },\n  onChange: () => {\n    // no-op\n  }\n};\n\n// Note: When using SketchPicker, the parent component CustomPicker can be invoked as a function without props by ReactDOM.\nconst CustomPicker: React.FC<CustomPickerProps> = (props = defaultProps) => {\n  const {color, onChange, theme} = props;\n\n  const pickerStyle = useMemo(\n    () => ({\n      picker: {\n        width: '200px',\n        padding: '10px 10px 8px',\n        boxSizing: 'initial',\n        background: theme.panelBackground\n      }\n    }),\n    [theme.panelBackground]\n  );\n\n  return (\n    <StyledPicker>\n      <SketchPicker\n        color={color}\n        onChange={onChange}\n        presetColors={PRESET_COLORS}\n        styles={pickerStyle}\n        disableAlpha\n      />\n    </StyledPicker>\n  );\n};\n\nexport default withTheme(CustomPicker) as React.FC<Omit<CustomPickerProps, 'theme'>>;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import DatasetLayerSectionFactory from './dataset-layer-section';
+DatasetLayerGroupFactory.deps = [DatasetLayerSectionFactory];
+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,
+      mapStateActions = props.mapStateActions,
+      mapState = props.mapState;
+    var datasetLayerSectionData = useMemo(function () {
+      return Object.values(datasets).map(function (dataset) {
+        // Global layer order will contain the correct order of layers
+        // We just empty the positions in layers array (for each dataset)
+        // where the layer doesn't belong to a dataset and set it to null
+        var datasetLayers = layers.map(function (layer) {
+          return layer.config.dataId === dataset.id ? layer : null;
+        }).filter(function (layer) {
+          return Boolean(layer);
+        });
+        return {
+          dataset: dataset,
+          datasetLayers: datasetLayers
+        };
+      });
+    }, [datasets, layers]);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, datasetLayerSectionData.map(function (dlsData) {
+      return /*#__PURE__*/React.createElement(DatasetLayerSection, {
+        key: dlsData.dataset.id,
+        dataset: dlsData.dataset,
+        layers: dlsData.datasetLayers,
+        datasets: datasets,
+        showDatasetTable: showDatasetTable,
+        updateTableColor: updateTableColor,
+        showDeleteDataset: showDeleteDataset,
+        removeDataset: removeDataset,
+        layerOrder: layerOrder,
+        layerClasses: layerClasses,
+        uiStateActions: uiStateActions,
+        visStateActions: visStateActions,
+        mapStateActions: mapStateActions,
+        mapState: mapState
+      });
+    }));
+  };
+  return DatasetLayerGroup;
+}
+export default DatasetLayerGroupFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,94 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _excluded = ["rasterTile"],
+  _excluded2 = ["wms"],
+  _excluded3 = ["flow"],
+  _excluded4 = ["bitmap"];
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+import LayerListFactory from './layer-list';
+import { getApplicationConfig } from '@kepler.gl/utils';
+var DatasetLayerSectionWrapper = styled.div.attrs({
+  className: 'dataset-layer-section'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  margin-bottom: 16px;\n"])));
+DatasetLayerSectionFactory.deps = [SourceDataCatalogFactory, LayerListFactory];
+function DatasetLayerSectionFactory(SourceDataCatalog, LayerList) {
+  var DatasetLayerSection = function DatasetLayerSection(props) {
+    var dataset = props.dataset,
+      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,
+      mapStateActions = props.mapStateActions,
+      mapState = props.mapState;
+    var datasetCatalog = useMemo(function () {
+      return _defineProperty({}, dataset.id, dataset);
+    }, [dataset]);
+
+    // temp patch to hide layers that are in development
+    var enableRasterTileLayer = getApplicationConfig().enableRasterTileLayer;
+    var enableWMSLayer = getApplicationConfig().enableWMSLayer;
+    var enableFlowLayer = getApplicationConfig().enableFlowLayer;
+    var enableBitmapLayer = getApplicationConfig().enableBitmapLayer;
+    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;
+      }
+      if (!enableBitmapLayer) {
+        var _filteredClasses4 = filteredClasses,
+          _bitmap = _filteredClasses4.bitmap,
+          _rest3 = _objectWithoutProperties(_filteredClasses4, _excluded4);
+        filteredClasses = _rest3;
+      }
+      return filteredClasses;
+    }, [enableRasterTileLayer, enableWMSLayer, enableFlowLayer, enableBitmapLayer, layerClasses]);
+    return /*#__PURE__*/React.createElement(DatasetLayerSectionWrapper, null, /*#__PURE__*/React.createElement(SourceDataCatalog, {
+      datasets: datasetCatalog,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: showDeleteDataset
+    }), /*#__PURE__*/React.createElement(LayerList, {
+      datasets: datasets,
+      layerOrder: layerOrder,
+      layers: layers,
+      layerClasses: filteredLayerClasses,
+      uiStateActions: uiStateActions,
+      visStateActions: visStateActions,
+      mapStateActions: mapStateActions,
+      mapState: mapState,
+      isSortable: false
+    }));
+  };
+  return DatasetLayerSection;
+}
+export default DatasetLayerSectionFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","styled","SourceDataCatalogFactory","LayerListFactory","getApplicationConfig","DatasetLayerSectionWrapper","div","attrs","className","_templateObject","_taggedTemplateLiteral","DatasetLayerSectionFactory","deps","SourceDataCatalog","LayerList","DatasetLayerSection","props","dataset","datasets","showDatasetTable","layers","updateTableColor","showDeleteDataset","removeDataset","layerOrder","layerClasses","uiStateActions","visStateActions","mapStateActions","mapState","datasetCatalog","_defineProperty","id","enableRasterTileLayer","enableWMSLayer","enableFlowLayer","enableBitmapLayer","filteredLayerClasses","filteredClasses","_filteredClasses","_rasterTile","rasterTile","rest","_objectWithoutProperties","_excluded","_filteredClasses2","_wms","wms","_excluded2","_filteredClasses3","_flow","flow","_excluded3","_filteredClasses4","_bitmap","bitmap","_excluded4","createElement","isSortable"],"sources":["../../../../src/side-panel/layer-panel/dataset-layer-section.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\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 '@kepler.gl/layers';\nimport {UIStateActions, ActionHandler, VisStateActions, MapStateActions} from '@kepler.gl/actions';\nimport {KeplerTable, Datasets} from '@kepler.gl/table';\nimport {getApplicationConfig} from '@kepler.gl/utils';\nimport {LayerOrder, MapState} from '@kepler.gl/types';\n\ntype DatasetLayerSectionProps = {\n  datasets: Datasets;\n  dataset: KeplerTable;\n  layers: Layer[];\n  layerOrder: LayerOrder;\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  mapStateActions: typeof MapStateActions;\n  mapState?: MapState;\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      datasets,\n      showDatasetTable,\n      layers,\n      updateTableColor,\n      showDeleteDataset,\n      removeDataset,\n      layerOrder,\n      layerClasses,\n      uiStateActions,\n      visStateActions,\n      mapStateActions,\n      mapState\n    } = props;\n\n    const datasetCatalog = useMemo(() => {\n      return {[dataset.id]: dataset};\n    }, [dataset]);\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 enableBitmapLayer = getApplicationConfig().enableBitmapLayer;\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      if (!enableBitmapLayer) {\n        const {bitmap: _bitmap, ...rest} = filteredClasses;\n        filteredClasses = rest as LayerClassesType;\n      }\n      return filteredClasses as LayerClassesType;\n    }, [enableRasterTileLayer, enableWMSLayer, enableFlowLayer, enableBitmapLayer, layerClasses]);\n\n    return (\n      <DatasetLayerSectionWrapper>\n        <SourceDataCatalog\n          datasets={datasetCatalog}\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={filteredLayerClasses}\n          uiStateActions={uiStateActions}\n          visStateActions={visStateActions}\n          mapStateActions={mapStateActions}\n          mapState={mapState}\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/esm/side-panel/layer-panel/dataset-section.js

@@ -0,0 +1,68 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { Add } from '../../common/icons';
+import { Button } from '../../common/styled-components';
+import SourceDataCatalogFactory from '../common/source-data-catalog';
+var StyledDatasetTitle = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\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 = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  border-bottom: 1px solid ", ";\n"])), function (props) {
+  return props.theme.sidePanelBorderColor;
+});
+export function AddDataButtonFactory() {
+  var AddDataButton = /*#__PURE__*/React.memo(function (_ref) {
+    var onClick = _ref.onClick,
+      isInactive = _ref.isInactive;
+    return /*#__PURE__*/React.createElement(Button, {
+      className: "add-data-button",
+      onClick: onClick,
+      inactive: !isInactive,
+      width: "105px",
+      secondary: true
+    }, /*#__PURE__*/React.createElement(Add, {
+      height: "12px"
+    }), /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'layerManager.addData'
+    }));
+  });
+  AddDataButton.displayName = 'AddDataButton';
+  return AddDataButton;
+}
+DatasetSectionFactory.deps = [SourceDataCatalogFactory, 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;
+    var datasetCount = Object.keys(datasets).length;
+    return /*#__PURE__*/React.createElement(StyledDatasetSection, null, /*#__PURE__*/React.createElement(StyledDatasetTitle, {
+      $showDatasetList: showDatasetList
+    }, /*#__PURE__*/React.createElement("span", null, "Datasets", datasetCount ? "(".concat(datasetCount, ")") : ''), /*#__PURE__*/React.createElement(AddDataButton, {
+      onClick: showAddDataModal,
+      isInactive: !datasetCount
+    })), showDatasetList && /*#__PURE__*/React.createElement(SourceDataCatalog, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor,
+      removeDataset: removeDataset,
+      showDeleteDataset: showDeleteDataset
+    }));
+  };
+  return DatasetSection;
+}
+export default DatasetSectionFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","styled","FormattedMessage","Add","Button","SourceDataCatalogFactory","StyledDatasetTitle","div","_templateObject","_taggedTemplateLiteral","props","theme","sidePanelTitleLineHeight","subtextColor","$showDatasetList","StyledDatasetSection","_templateObject2","sidePanelBorderColor","AddDataButtonFactory","AddDataButton","memo","_ref","onClick","isInactive","createElement","className","inactive","width","secondary","height","id","displayName","DatasetSectionFactory","deps","SourceDataCatalog","DatasetSection","datasets","showDatasetTable","updateTableColor","showDeleteDataset","removeDataset","showDatasetList","showAddDataModal","datasetCount","Object","keys","length","concat"],"sources":["../../../../src/side-panel/layer-panel/dataset-section.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React from 'react';\nimport styled from 'styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {Add} from '../../common/icons';\nimport {Button} from '../../common/styled-components';\n\nimport SourceDataCatalogFactory from '../common/source-data-catalog';\nimport {UIStateActions, VisStateActions, ActionHandler} from '@kepler.gl/actions';\nimport {Datasets} from '@kepler.gl/table';\n\ntype AddDataButtonProps = {\n  onClick: () => void;\n  isInactive: boolean;\n};\n\ntype DatasetSectionProps = {\n  datasets: Datasets;\n  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  border-bottom: 1px solid ${props => props.theme.sidePanelBorderColor};\n`;\n\nexport function AddDataButtonFactory() {\n  const AddDataButton: React.FC<AddDataButtonProps> = React.memo(({onClick, isInactive}) => (\n    <Button\n      className=\"add-data-button\"\n      onClick={onClick}\n      inactive={!isInactive}\n      width=\"105px\"\n      secondary\n    >\n      <Add height=\"12px\" />\n      <FormattedMessage id={'layerManager.addData'} />\n    </Button>\n  ));\n  AddDataButton.displayName = 'AddDataButton';\n  return AddDataButton;\n}\n\nDatasetSectionFactory.deps = [SourceDataCatalogFactory, AddDataButtonFactory];\n\nfunction DatasetSectionFactory(\n  SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>,\n  AddDataButton: ReturnType<typeof AddDataButtonFactory>\n) {\n  const DatasetSection: React.FC<DatasetSectionProps> = props => {\n    const {\n      datasets,\n      showDatasetTable,\n      updateTableColor,\n      showDeleteDataset,\n      removeDataset,\n      showDatasetList,\n      showAddDataModal\n    } = props;\n    const datasetCount = Object.keys(datasets).length;\n\n    return (\n      <StyledDatasetSection>\n        <StyledDatasetTitle $showDatasetList={showDatasetList}>\n          <span>Datasets{datasetCount ? `(${datasetCount})` : ''}</span>\n          <AddDataButton onClick={showAddDataModal} isInactive={!datasetCount} />\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/esm/side-panel/layer-panel/dimension-scale-selector.js

@@ -0,0 +1,82 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectDestructuringEmpty from "@babel/runtime/helpers/esm/objectDestructuringEmpty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { CHANNEL_SCALES, SCALE_TYPE_NAMES } from '@kepler.gl/constants';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { camelize } from '@kepler.gl/utils';
+import { default as React, useCallback } from 'react';
+import ItemSelector from '../../common/item-selector/item-selector';
+import { PanelLabel, SidePanelSection } from '../../common/styled-components';
+import ColorScaleSelectorFactory from './color-scale-selector';
+var SizeScaleSelector = function SizeScaleSelector(_ref) {
+  var dropdownSelectProps = _extends({}, (_objectDestructuringEmpty(_ref), _ref));
+  return /*#__PURE__*/React.createElement(ItemSelector, dropdownSelectProps);
+};
+DimensionScaleSelectorFactory.deps = [ColorScaleSelectorFactory];
+function DimensionScaleSelectorFactory(ColorScaleSelector) {
+  var DimensionScaleSelector = function DimensionScaleSelector(_ref2) {
+    var _layer$config$colorUI;
+    var layer = _ref2.layer,
+      channel = _ref2.channel,
+      dataset = _ref2.dataset,
+      label = _ref2.label,
+      onChange = _ref2.onChange,
+      setColorUI = _ref2.setColorUI;
+    var channelScaleType = channel.channelScaleType,
+      domain = channel.domain,
+      field = channel.field,
+      key = channel.key,
+      range = channel.range,
+      scale = channel.scale;
+    var scaleType = scale ? layer.config[scale] : null;
+    var layerScaleOptions = layer.getScaleOptions(key);
+    var scaleOptions = layerScaleOptions.map(function (op) {
+      return {
+        label: SCALE_TYPE_NAMES[op] || op,
+        value: op
+      };
+    });
+    var disabled = scaleOptions.length < 2;
+    var isColorScale = channelScaleType === CHANNEL_SCALES.color || layer.config.aggregatedBins && channelScaleType === CHANNEL_SCALES.colorAggr;
+    var onSelect = useCallback(function (val, newRange) {
+      return onChange(_defineProperty({}, scale, val), key, newRange ? _defineProperty({}, range, newRange) : undefined);
+    }, [onChange, range, scale, key]);
+    var _setColorUI = useCallback(function (newConfig) {
+      return setColorUI(range, newConfig);
+    }, [range, setColorUI]);
+    var dropdownSelectProps = {
+      disabled: disabled,
+      selectedItems: scaleOptions.filter(function (op) {
+        return op.value === scaleType;
+      }),
+      options: scaleOptions,
+      multiSelect: false,
+      searchable: false,
+      onChange: onSelect,
+      displayOption: 'label',
+      getOptionValue: 'value',
+      channelKey: key
+    };
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: label ? "scale.".concat(camelize(label)) : 'misc.scale',
+      defaultMessage: label
+    })), isColorScale && dataset ? /*#__PURE__*/React.createElement(ColorScaleSelector, _extends({}, dropdownSelectProps, {
+      layer: layer,
+      field: layer.config[field],
+      dataset: dataset,
+      onSelect: onSelect,
+      scaleType: scaleType,
+      domain: layer.config[domain],
+      aggregatedBins: layer.config.aggregatedBins,
+      range: layer.config.visConfig[range],
+      setColorUI: _setColorUI,
+      colorUIConfig: (_layer$config$colorUI = layer.config.colorUI) === null || _layer$config$colorUI === void 0 ? void 0 : _layer$config$colorUI[range]
+    })) : /*#__PURE__*/React.createElement(SizeScaleSelector, dropdownSelectProps));
+  };
+  return DimensionScaleSelector;
+}
+export default DimensionScaleSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CHANNEL_SCALES","SCALE_TYPE_NAMES","FormattedMessage","camelize","default","React","useCallback","ItemSelector","PanelLabel","SidePanelSection","ColorScaleSelectorFactory","SizeScaleSelector","_ref","dropdownSelectProps","_extends","_objectDestructuringEmpty","createElement","DimensionScaleSelectorFactory","deps","ColorScaleSelector","DimensionScaleSelector","_ref2","_layer$config$colorUI","layer","channel","dataset","label","onChange","setColorUI","channelScaleType","domain","field","key","range","scale","scaleType","config","layerScaleOptions","getScaleOptions","scaleOptions","map","op","value","disabled","length","isColorScale","color","aggregatedBins","colorAggr","onSelect","val","newRange","_defineProperty","undefined","_setColorUI","newConfig","selectedItems","filter","options","multiSelect","searchable","displayOption","getOptionValue","channelKey","id","concat","defaultMessage","visConfig","colorUIConfig","colorUI"],"sources":["../../../../src/side-panel/layer-panel/dimension-scale-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {CHANNEL_SCALES, SCALE_TYPE_NAMES} from '@kepler.gl/constants';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {ColorUI, LayerVisConfig} from '@kepler.gl/types';\nimport {camelize} from '@kepler.gl/utils';\nimport {Layer, VisualChannel} from '@kepler.gl/layers';\nimport {default as React, useCallback} from 'react';\nimport {Field} from '@kepler.gl/types';\nimport ItemSelector from '../../common/item-selector/item-selector';\nimport {PanelLabel, SidePanelSection} from '../../common/styled-components';\nimport ColorScaleSelectorFactory from './color-scale-selector';\nimport {KeplerTable} from '@kepler.gl/table';\n\nconst SizeScaleSelector = ({...dropdownSelectProps}: any) => (\n  <ItemSelector {...dropdownSelectProps} />\n);\n\nexport type DimensionScaleSelectorProps = {\n  layer: Layer;\n  channel: VisualChannel;\n  label?: string;\n  dataset: KeplerTable | undefined;\n  onChange: (\n    newConfig: {[key: string]: Field | null | string},\n    key: string,\n    newVisConfig?: Partial<LayerVisConfig>\n  ) => void;\n  setColorUI: (range: string, newConfig: {[key in keyof ColorUI]: ColorUI[key]}) => void;\n};\n\nDimensionScaleSelectorFactory.deps = [ColorScaleSelectorFactory];\n\nfunction DimensionScaleSelectorFactory(\n  ColorScaleSelector: ReturnType<typeof ColorScaleSelectorFactory>\n): React.FC<DimensionScaleSelectorProps> {\n  const DimensionScaleSelector: React.FC<DimensionScaleSelectorProps> = ({\n    layer,\n    channel,\n    dataset,\n    label,\n    onChange,\n    setColorUI\n  }) => {\n    const {channelScaleType, domain, field, key, range, scale} = channel;\n    const scaleType = scale ? layer.config[scale] : null;\n    const layerScaleOptions = layer.getScaleOptions(key);\n    const scaleOptions = layerScaleOptions.map(op => ({\n      label: SCALE_TYPE_NAMES[op] || op,\n      value: op\n    }));\n    const disabled = scaleOptions.length < 2;\n    const isColorScale =\n      channelScaleType === CHANNEL_SCALES.color ||\n      (layer.config.aggregatedBins && channelScaleType === CHANNEL_SCALES.colorAggr);\n\n    const onSelect = useCallback(\n      (val, newRange) => onChange({[scale]: val}, key, newRange ? {[range]: newRange} : undefined),\n      [onChange, range, scale, key]\n    );\n    const _setColorUI = useCallback(newConfig => setColorUI(range, newConfig), [range, setColorUI]);\n\n    const dropdownSelectProps = {\n      disabled,\n      selectedItems: scaleOptions.filter(op => op.value === scaleType),\n      options: scaleOptions,\n      multiSelect: false,\n      searchable: false,\n      onChange: onSelect,\n      displayOption: 'label',\n      getOptionValue: 'value',\n      channelKey: key\n    };\n\n    return (\n      <SidePanelSection>\n        <PanelLabel>\n          <FormattedMessage\n            id={label ? `scale.${camelize(label)}` : 'misc.scale'}\n            defaultMessage={label}\n          />\n        </PanelLabel>\n        {isColorScale && dataset ? (\n          <ColorScaleSelector\n            {...dropdownSelectProps}\n            layer={layer}\n            field={layer.config[field]}\n            dataset={dataset}\n            onSelect={onSelect}\n            scaleType={scaleType}\n            domain={layer.config[domain]}\n            aggregatedBins={layer.config.aggregatedBins}\n            range={layer.config.visConfig[range]}\n            setColorUI={_setColorUI}\n            colorUIConfig={layer.config.colorUI?.[range]}\n          />\n        ) : (\n          <SizeScaleSelector {...dropdownSelectProps} />\n        )}\n      </SidePanelSection>\n    );\n  };\n  return DimensionScaleSelector;\n}\n\nexport default DimensionScaleSelectorFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/side-panel/layer-panel/how-to-button.js

@@ -0,0 +1,22 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { Button } from '../../common/styled-components';
+var StyledHowToButton = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: absolute;\n  right: 12px;\n  top: -4px;\n"])));
+export var HowToButton = function HowToButton(_ref) {
+  var onClick = _ref.onClick;
+  return /*#__PURE__*/React.createElement(StyledHowToButton, null, /*#__PURE__*/React.createElement(Button, {
+    link: true,
+    small: true,
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'layerConfiguration.howTo'
+  })));
+};
+export default HowToButton;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,94 @@
+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 ColorSelectorFactory from './color-selector';
+import { SidePanelSection } from '../../common/styled-components';
+LayerColorSelectorFactory.deps = [ColorSelectorFactory];
+export function LayerColorSelectorFactory(ColorSelector) {
+  var LayerColorSelector = function LayerColorSelector(_ref) {
+    var layer = _ref.layer,
+      onChange = _ref.onChange,
+      selectedColor = _ref.selectedColor,
+      _ref$property = _ref.property,
+      property = _ref$property === void 0 ? 'color' : _ref$property,
+      setColorUI = _ref.setColorUI;
+    var onSetColorUI = useCallback(function (newConfig) {
+      return setColorUI(property, newConfig);
+    }, [setColorUI, property]);
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(ColorSelector, {
+      colorSets: [{
+        selectedColor: selectedColor || layer.config.color,
+        setColor: function setColor(rgbValue) {
+          return onChange(_defineProperty({}, property, rgbValue));
+        }
+      }],
+      colorUI: layer.config.colorUI[property],
+      setColorUI: onSetColorUI
+    }));
+  };
+  return LayerColorSelector;
+}
+LayerColorRangeSelectorFactory.deps = [ColorSelectorFactory];
+export function LayerColorRangeSelectorFactory(ColorSelector) {
+  var LayerColorRangeSelector = function LayerColorRangeSelector(_ref2) {
+    var layer = _ref2.layer,
+      onChange = _ref2.onChange,
+      _ref2$property = _ref2.property,
+      property = _ref2$property === void 0 ? 'colorRange' : _ref2$property,
+      setColorUI = _ref2.setColorUI;
+    var onSetColorUI = useCallback(function (newConfig) {
+      return setColorUI(property, newConfig);
+    }, [setColorUI, property]);
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(ColorSelector, {
+      colorSets: [{
+        selectedColor: layer.config.visConfig[property],
+        isRange: true,
+        setColor: function setColor(colorRange) {
+          return onChange(_defineProperty({}, property, colorRange));
+        }
+      }],
+      colorUI: layer.config.colorUI[property],
+      setColorUI: onSetColorUI
+    }));
+  };
+  return LayerColorRangeSelector;
+}
+ArcLayerColorSelectorFactory.deps = [ColorSelectorFactory];
+export function ArcLayerColorSelectorFactory(ColorSelector) {
+  var ArcLayerColorSelector = function ArcLayerColorSelector(_ref3) {
+    var layer = _ref3.layer,
+      onChangeConfig = _ref3.onChangeConfig,
+      onChangeVisConfig = _ref3.onChangeVisConfig,
+      _ref3$property = _ref3.property,
+      property = _ref3$property === void 0 ? 'color' : _ref3$property,
+      setColorUI = _ref3.setColorUI;
+    var onSetColorUI = useCallback(function (newConfig) {
+      return setColorUI(property, newConfig);
+    }, [setColorUI, property]);
+    return /*#__PURE__*/React.createElement(SidePanelSection, null, /*#__PURE__*/React.createElement(ColorSelector, {
+      colorSets: [{
+        selectedColor: layer.config.color,
+        setColor: function setColor(rgbValue) {
+          return onChangeConfig({
+            color: rgbValue
+          });
+        },
+        label: 'Source'
+      }, {
+        selectedColor: layer.config.visConfig.targetColor || layer.config.color,
+        setColor: function setColor(rgbValue) {
+          return onChangeVisConfig({
+            targetColor: rgbValue
+          });
+        },
+        label: 'Target'
+      }],
+      colorUI: layer.config.colorUI[property],
+      setColorUI: onSetColorUI
+    }));
+  };
+  return ArcLayerColorSelector;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","ColorSelectorFactory","SidePanelSection","LayerColorSelectorFactory","deps","ColorSelector","LayerColorSelector","_ref","layer","onChange","selectedColor","_ref$property","property","setColorUI","onSetColorUI","newConfig","createElement","colorSets","config","color","setColor","rgbValue","_defineProperty","colorUI","LayerColorRangeSelectorFactory","LayerColorRangeSelector","_ref2","_ref2$property","visConfig","isRange","colorRange","ArcLayerColorSelectorFactory","ArcLayerColorSelector","_ref3","onChangeConfig","onChangeVisConfig","_ref3$property","label","targetColor"],"sources":["../../../../src/side-panel/layer-panel/layer-color-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback} from 'react';\n\nimport {ColorRange} from '@kepler.gl/types';\nimport {Layer} from '@kepler.gl/layers';\nimport {NestedPartial, RGBColor, ColorUI} from '@kepler.gl/types';\n\nimport ColorSelectorFactory from './color-selector';\nimport {SidePanelSection} from '../../common/styled-components';\n\ntype LayerColorSelectorProps = {\n  layer: Layer;\n  onChange: (v: Record<string, RGBColor>) => void;\n  selectedColor?: RGBColor;\n  property?: string;\n  setColorUI: (prop: string, newConfig: NestedPartial<ColorUI>) => void;\n};\n\ntype ArcLayerColorSelectorProps = {\n  layer: Layer;\n  onChangeConfig: (v: {color: RGBColor}) => void;\n  onChangeVisConfig: (v: {targetColor: RGBColor}) => void;\n  property?: string;\n  setColorUI: (prop: string, newConfig: NestedPartial<ColorUI>) => void;\n};\n\ntype LayerColorRangeSelectorProps = {\n  layer: Layer;\n  onChange: (v: Record<string, ColorRange>) => void;\n  property?: string;\n  setColorUI: (prop: string, newConfig: NestedPartial<ColorUI>) => void;\n};\n\nLayerColorSelectorFactory.deps = [ColorSelectorFactory];\nexport function LayerColorSelectorFactory(ColorSelector) {\n  const LayerColorSelector = ({\n    layer,\n    onChange,\n    selectedColor,\n    property = 'color',\n    setColorUI\n  }: LayerColorSelectorProps) => {\n    const onSetColorUI = useCallback(\n      newConfig => setColorUI(property, newConfig),\n      [setColorUI, property]\n    );\n\n    return (\n      <SidePanelSection>\n        <ColorSelector\n          colorSets={[\n            {\n              selectedColor: selectedColor || layer.config.color,\n              setColor: (rgbValue: RGBColor) => onChange({[property]: rgbValue})\n            }\n          ]}\n          colorUI={layer.config.colorUI[property]}\n          setColorUI={onSetColorUI}\n        />\n      </SidePanelSection>\n    );\n  };\n  return LayerColorSelector;\n}\n\nLayerColorRangeSelectorFactory.deps = [ColorSelectorFactory];\nexport function LayerColorRangeSelectorFactory(ColorSelector) {\n  const LayerColorRangeSelector = ({\n    layer,\n    onChange,\n    property = 'colorRange',\n    setColorUI\n  }: LayerColorRangeSelectorProps) => {\n    const onSetColorUI = useCallback(\n      newConfig => setColorUI(property, newConfig),\n      [setColorUI, property]\n    );\n\n    return (\n      <SidePanelSection>\n        <ColorSelector\n          colorSets={[\n            {\n              selectedColor: layer.config.visConfig[property],\n              isRange: true,\n              setColor: (colorRange: ColorRange) => onChange({[property]: colorRange})\n            }\n          ]}\n          colorUI={layer.config.colorUI[property]}\n          setColorUI={onSetColorUI}\n        />\n      </SidePanelSection>\n    );\n  };\n  return LayerColorRangeSelector;\n}\n\nArcLayerColorSelectorFactory.deps = [ColorSelectorFactory];\nexport function ArcLayerColorSelectorFactory(ColorSelector) {\n  const ArcLayerColorSelector = ({\n    layer,\n    onChangeConfig,\n    onChangeVisConfig,\n    property = 'color',\n    setColorUI\n  }: ArcLayerColorSelectorProps) => {\n    const onSetColorUI = useCallback(\n      newConfig => setColorUI(property, newConfig),\n      [setColorUI, property]\n    );\n\n    return (\n      <SidePanelSection>\n        <ColorSelector\n          colorSets={[\n            {\n              selectedColor: layer.config.color,\n              setColor: (rgbValue: RGBColor) => onChangeConfig({color: rgbValue}),\n              label: 'Source'\n            },\n            {\n              selectedColor: layer.config.visConfig.targetColor || layer.config.color,\n              setColor: (rgbValue: RGBColor) => onChangeVisConfig({targetColor: rgbValue}),\n              label: 'Target'\n            }\n          ]}\n          colorUI={layer.config.colorUI[property]}\n          setColorUI={onSetColorUI}\n        />\n      </SidePanelSection>\n    );\n  };\n  return ArcLayerColorSelector;\n}\n"],"mappings":"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","ignoreList":[]}