@kepler.gl/components 3.1.0-alpha.0 → 3.1.0-alpha.2

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

@@ -0,0 +1,244 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.PaletteConfig = exports.ColorPaletteItem = exports.ALL_TYPES = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _constants = require("@kepler.gl/constants");
+var _localization = require("@kepler.gl/localization");
+var _utils = require("@kepler.gl/utils");
+var _itemSelector = _interopRequireDefault(require("../../common/item-selector/item-selector"));
+var _styledComponents2 = require("../../common/styled-components");
+var _switch = _interopRequireDefault(require("../../common/switch"));
+var _colorPalette = _interopRequireDefault(require("./color-palette"));
+var _customPalette = _interopRequireDefault(require("./custom-palette"));
+var _d3Array = require("d3-array");
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// @ts-ignore cant concat 'all' to PALETTE_TYPES values
+var ALL_TYPES = exports.ALL_TYPES = Object.values(_constants.PALETTE_TYPES).concat(['all']);
+var MAX_STEPS = 20;
+var ALL_STEPS = (0, _d3Array.range)(2, MAX_STEPS + 1, 1);
+var StyledColorConfig = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  padding: 12px 12px 0 12px;\n"])));
+var StyledColorRangeSelector = _styledComponents["default"].div.attrs({
+  className: 'color-range-selector'
+})(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  padding-bottom: 12px;\n"])));
+var StyledColorPalette = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  padding: 0 8px 8px 8px;\n"])));
+var StyledPaletteConfig = _styledComponents["default"].div(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  margin-bottom: 8px;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n\n  .color-palette__config__select {\n    width: 40%;\n    display: flex;\n    flex-direction: row-reverse;\n\n    .item-selector {\n      width: 100%;\n    }\n  }\n"])));
+var CONFIG_SETTINGS = {
+  type: {
+    type: 'select',
+    options: ALL_TYPES
+  },
+  steps: {
+    type: 'select',
+    options: ALL_STEPS,
+    disabled: function disabled(colorRange) {
+      return (0, _utils.hasColorMap)(colorRange);
+    },
+    reason: 'color.disableStepReason'
+  },
+  reversed: {
+    type: 'switch',
+    options: [true, false]
+  },
+  colorBlindSafe: {
+    type: 'switch',
+    options: [true, false]
+  },
+  custom: {
+    label: 'customPalette',
+    type: 'switch',
+    options: [true, false]
+  }
+};
+var displayOption = function displayOption(d) {
+  return (0, _utils.capitalizeFirstLetter)(d);
+};
+var getOptionValue = function getOptionValue(d) {
+  return d;
+};
+ColorRangeSelectorFactory.deps = [_customPalette["default"]];
+function ColorRangeSelectorFactory(CustomPalette) {
+  var ColorRangeSelector = function ColorRangeSelector(_ref) {
+    var colorPalettes = _ref.colorPalettes,
+      colorPaletteUI = _ref.colorPaletteUI,
+      setColorPaletteUI = _ref.setColorPaletteUI,
+      onSelectColorRange = _ref.onSelectColorRange,
+      selectedColorRange = _ref.selectedColorRange;
+    var customPalette = colorPaletteUI.customPalette,
+      showSketcher = colorPaletteUI.showSketcher,
+      colorRangeConfig = colorPaletteUI.colorRangeConfig;
+    var type = colorRangeConfig.type,
+      steps = colorRangeConfig.steps,
+      colorBlindSafe = colorRangeConfig.colorBlindSafe,
+      reversed = colorRangeConfig.reversed;
+    var filteredColorPalettes = (0, _react.useMemo)(function () {
+      var _colorPalettes$filter;
+      return (_colorPalettes$filter = colorPalettes === null || colorPalettes === void 0 ? void 0 : colorPalettes.filter(function (palette) {
+        return (0, _utils.paletteIsType)(palette, type) && (0, _utils.paletteIsSteps)(palette, steps) && (0, _utils.paletteIsColorBlindSafe)(palette, colorBlindSafe);
+      })) !== null && _colorPalettes$filter !== void 0 ? _colorPalettes$filter : [];
+    }, [colorPalettes, colorBlindSafe, steps, type]);
+    var _updateConfig = (0, _react.useCallback)(function (_ref2) {
+      var key = _ref2.key,
+        value = _ref2.value;
+      setColorPaletteUI({
+        colorRangeConfig: (0, _defineProperty2["default"])({}, key, value)
+      });
+    }, [setColorPaletteUI]);
+    var _onCustomPaletteCancel = (0, _react.useCallback)(function () {
+      setColorPaletteUI({
+        showSketcher: false,
+        colorRangeConfig: {
+          custom: false
+        }
+      });
+    }, [setColorPaletteUI]);
+    var _onApply = (0, _react.useCallback)(function (e) {
+      return onSelectColorRange(customPalette, e);
+    }, [customPalette, onSelectColorRange]);
+    var _onSelectPalette = (0, _react.useCallback)(function (colorPalette, e) {
+      var newColorRange = (0, _utils.updateColorRangeBySelectedPalette)(selectedColorRange, colorPalette, {
+        steps: steps,
+        reversed: reversed
+      });
+      onSelectColorRange(newColorRange, e);
+    }, [selectedColorRange, reversed, steps, onSelectColorRange]);
+    return /*#__PURE__*/_react["default"].createElement(StyledColorRangeSelector, null, /*#__PURE__*/_react["default"].createElement(StyledColorConfig, null, (colorRangeConfig.custom ? ['custom'] : Object.keys(colorRangeConfig)).map(function (key) {
+      return CONFIG_SETTINGS[key] ? /*#__PURE__*/_react["default"].createElement(PaletteConfig, {
+        key: key,
+        prop: key,
+        label: CONFIG_SETTINGS[key].label || key,
+        config: CONFIG_SETTINGS[key],
+        value: colorRangeConfig[key],
+        onChange: _updateConfig,
+        disabled: CONFIG_SETTINGS[key].disabled ? CONFIG_SETTINGS[key].disabled(selectedColorRange) : false,
+        reason: CONFIG_SETTINGS[key].reason
+      }) : null;
+    })), colorRangeConfig.custom ? /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(StyledColorPalette, null, /*#__PURE__*/_react["default"].createElement(_colorPalette["default"], {
+      colors: customPalette.colors
+    })), /*#__PURE__*/_react["default"].createElement(CustomPalette, {
+      customPalette: customPalette,
+      showSketcher: showSketcher,
+      onApply: _onApply,
+      setColorPaletteUI: setColorPaletteUI,
+      onCancel: _onCustomPaletteCancel
+    })) : /*#__PURE__*/_react["default"].createElement("div", {
+      className: "color-palette__group"
+    }, filteredColorPalettes.map(function (colorPalette, i) {
+      return /*#__PURE__*/_react["default"].createElement(ColorPaletteItem, {
+        key: "".concat(colorPalette.name, "-").concat(i),
+        colorPalette: colorPalette,
+        selectedColorRange: selectedColorRange,
+        onSelect: _onSelectPalette,
+        reversed: reversed,
+        steps: steps
+      });
+    })));
+  };
+  ColorRangeSelector.defaultProps = {
+    colorPalettes: _constants.KEPLER_COLOR_PALETTES,
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    onSelectColorRange: function onSelectColorRange() {},
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    setColorPaletteUI: function setColorPaletteUI() {}
+  };
+  return ColorRangeSelector;
+}
+var PaletteConfig = exports.PaletteConfig = function PaletteConfig(_ref3) {
+  var prop = _ref3.prop,
+    label = _ref3.label,
+    value = _ref3.value,
+    _ref3$config = _ref3.config,
+    type = _ref3$config.type,
+    options = _ref3$config.options,
+    onChange = _ref3.onChange,
+    disabled = _ref3.disabled,
+    reason = _ref3.reason;
+  var updateSelect = (0, _react.useCallback)(function (val) {
+    return onChange({
+      key: prop,
+      value: val
+    });
+  }, [onChange, prop]);
+  var updateSwitch = (0, _react.useCallback)(function () {
+    return onChange({
+      key: prop,
+      value: !value
+    });
+  }, [onChange, prop, value]);
+  return /*#__PURE__*/_react["default"].createElement(StyledPaletteConfig, {
+    className: "color-palette__config",
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    }
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: "color-palette__config__label"
+  }, /*#__PURE__*/_react["default"].createElement(_styledComponents2.PanelLabel, null, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: "color.".concat(label)
+  }))), /*#__PURE__*/_react["default"].createElement("div", {
+    className: "color-palette__config__select",
+    "data-tip": true,
+    "data-for": "color-range-config-".concat(prop)
+  }, type === 'select' && /*#__PURE__*/_react["default"].createElement(_itemSelector["default"], {
+    selectedItems: value,
+    options: options,
+    multiSelect: false,
+    searchable: false,
+    onChange: updateSelect,
+    disabled: disabled,
+    inputTheme: "secondary",
+    displayOption: displayOption,
+    getOptionValue: getOptionValue
+  }), type === 'switch' && /*#__PURE__*/_react["default"].createElement(_switch["default"], {
+    checked: Boolean(value),
+    id: "".concat(label, "-toggle"),
+    onChange: updateSwitch,
+    disabled: disabled,
+    secondary: true
+  }), disabled && reason ? /*#__PURE__*/_react["default"].createElement(_styledComponents2.Tooltip, {
+    id: "color-range-config-".concat(prop),
+    place: "right"
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    style: {
+      maxWidth: '214px'
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+    id: reason
+  }))) : null));
+};
+var StyledColorRange = _styledComponents["default"].div.attrs({
+  className: 'color-palette-outer'
+})(_templateObject5 || (_templateObject5 = (0, _taggedTemplateLiteral2["default"])(["\n  padding: 0 8px;\n  :hover {\n    background-color: ", ";\n    cursor: pointer;\n  }\n"])), function (props) {
+  return props.theme.panelBackgroundHover;
+});
+var ColorPaletteItem = exports.ColorPaletteItem = function ColorPaletteItem(_ref4) {
+  var colorPalette = _ref4.colorPalette,
+    steps = _ref4.steps,
+    selectedColorRange = _ref4.selectedColorRange,
+    onSelect = _ref4.onSelect,
+    reversed = _ref4.reversed;
+  var colors = (0, _react.useMemo)(function () {
+    return colorPalette.colors(steps);
+  }, [colorPalette, steps]);
+  var onClick = (0, _react.useCallback)(function (e) {
+    return onSelect(colorPalette, e);
+  }, [colorPalette, onSelect]);
+  return /*#__PURE__*/_react["default"].createElement(StyledColorRange, {
+    onClick: onClick
+  }, /*#__PURE__*/_react["default"].createElement(_colorPalette["default"], {
+    colors: colors,
+    isReversed: reversed,
+    isSelected: colorPalette.name === selectedColorRange.name
+  }));
+};
+var _default = exports["default"] = ColorRangeSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_interopRequireDefault","_constants","_localization","_utils","_itemSelector","_styledComponents2","_switch","_colorPalette","_customPalette","_d3Array","_templateObject","_templateObject2","_templateObject3","_templateObject4","_templateObject5","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ALL_TYPES","exports","values","PALETTE_TYPES","concat","MAX_STEPS","ALL_STEPS","range","StyledColorConfig","styled","div","_taggedTemplateLiteral2","StyledColorRangeSelector","attrs","className","StyledColorPalette","StyledPaletteConfig","CONFIG_SETTINGS","type","options","steps","disabled","colorRange","hasColorMap","reason","reversed","colorBlindSafe","custom","label","displayOption","d","capitalizeFirstLetter","getOptionValue","ColorRangeSelectorFactory","deps","CustomPaletteFactory","CustomPalette","ColorRangeSelector","_ref","colorPalettes","colorPaletteUI","setColorPaletteUI","onSelectColorRange","selectedColorRange","customPalette","showSketcher","colorRangeConfig","filteredColorPalettes","useMemo","_colorPalettes$filter","filter","palette","paletteIsType","paletteIsSteps","paletteIsColorBlindSafe","_updateConfig","useCallback","_ref2","key","value","_defineProperty2","_onCustomPaletteCancel","_onApply","_onSelectPalette","colorPalette","newColorRange","updateColorRangeBySelectedPalette","createElement","keys","map","PaletteConfig","prop","config","onChange","Fragment","colors","onApply","onCancel","ColorPaletteItem","name","onSelect","defaultProps","KEPLER_COLOR_PALETTES","_ref3","_ref3$config","updateSelect","val","updateSwitch","onClick","stopPropagation","PanelLabel","FormattedMessage","id","selectedItems","multiSelect","searchable","inputTheme","checked","Boolean","secondary","Tooltip","place","style","maxWidth","StyledColorRange","props","theme","panelBackgroundHover","_ref4","isReversed","isSelected","_default"],"sources":["../../../src/side-panel/layer-panel/color-range-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {MouseEvent, useCallback, useMemo} from 'react';\nimport styled from 'styled-components';\nimport {KEPLER_COLOR_PALETTES, PALETTE_TYPES, ColorRange, ColorPalette} from '@kepler.gl/constants';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {ColorUI, NestedPartial} from '@kepler.gl/types';\nimport {\n  hasColorMap,\n  updateColorRangeBySelectedPalette,\n  paletteIsSteps,\n  paletteIsType,\n  paletteIsColorBlindSafe\n} from '@kepler.gl/utils';\nimport ItemSelector from '../../common/item-selector/item-selector';\nimport {PanelLabel, Tooltip} from '../../common/styled-components';\nimport Switch from '../../common/switch';\nimport ColorPalettePanel from './color-palette';\nimport CustomPaletteFactory from './custom-palette';\n\nimport {capitalizeFirstLetter} from '@kepler.gl/utils';\nimport {range} from 'd3-array';\n\ntype ColorRangeSelectorProps = {\n  colorPalettes?: ColorPalette[];\n  colorPaletteUI: ColorUI;\n  selectedColorRange: ColorRange;\n  onSelectColorRange: (p: ColorRange, e: MouseEvent) => void;\n  setColorPaletteUI: (newConfig: NestedPartial<ColorUI>) => void;\n};\n\ntype PaletteConfigProps = {\n  label: string;\n  value: string | number | boolean;\n  config: {\n    type: string;\n    options: (string | number | boolean)[];\n  };\n  onChange: (v: any) => void;\n  disabled?: boolean;\n  prop: string;\n  reason?: string;\n};\n\n// @ts-ignore cant concat 'all' to PALETTE_TYPES values\nexport const ALL_TYPES = Object.values(PALETTE_TYPES).concat(['all']);\nconst MAX_STEPS = 20;\nconst ALL_STEPS = range(2, MAX_STEPS + 1, 1);\n\nconst StyledColorConfig = styled.div`\n  padding: 12px 12px 0 12px;\n`;\n\nconst StyledColorRangeSelector = styled.div.attrs({\n  className: 'color-range-selector'\n})`\n  padding-bottom: 12px;\n`;\nconst StyledColorPalette = styled.div`\n  padding: 0 8px 8px 8px;\n`;\n\nconst StyledPaletteConfig = styled.div`\n  margin-bottom: 8px;\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n\n  .color-palette__config__select {\n    width: 40%;\n    display: flex;\n    flex-direction: row-reverse;\n\n    .item-selector {\n      width: 100%;\n    }\n  }\n`;\n\nconst CONFIG_SETTINGS = {\n  type: {\n    type: 'select',\n    options: ALL_TYPES\n  },\n  steps: {\n    type: 'select',\n    options: ALL_STEPS,\n    disabled: colorRange => hasColorMap(colorRange),\n    reason: 'color.disableStepReason'\n  },\n  reversed: {\n    type: 'switch',\n    options: [true, false]\n  },\n  colorBlindSafe: {\n    type: 'switch',\n    options: [true, false]\n  },\n  custom: {\n    label: 'customPalette',\n    type: 'switch',\n    options: [true, false]\n  }\n};\nconst displayOption = d => capitalizeFirstLetter(d);\nconst getOptionValue = d => d;\n\nColorRangeSelectorFactory.deps = [CustomPaletteFactory];\nfunction ColorRangeSelectorFactory(\n  CustomPalette: ReturnType<typeof CustomPaletteFactory>\n): React.FC<ColorRangeSelectorProps> {\n  const ColorRangeSelector: React.FC<ColorRangeSelectorProps> = ({\n    colorPalettes,\n    colorPaletteUI,\n    setColorPaletteUI,\n    onSelectColorRange,\n    selectedColorRange\n  }) => {\n    const {customPalette, showSketcher, colorRangeConfig} = colorPaletteUI;\n    const {type, steps, colorBlindSafe, reversed} = colorRangeConfig;\n\n    const filteredColorPalettes = useMemo(() => {\n      return (\n        colorPalettes?.filter(\n          palette =>\n            paletteIsType(palette, type) &&\n            paletteIsSteps(palette, steps) &&\n            paletteIsColorBlindSafe(palette, colorBlindSafe)\n        ) ?? []\n      );\n    }, [colorPalettes, colorBlindSafe, steps, type]);\n\n    const _updateConfig = useCallback(\n      ({key, value}) => {\n        setColorPaletteUI({colorRangeConfig: {[key]: value}});\n      },\n      [setColorPaletteUI]\n    );\n\n    const _onCustomPaletteCancel = useCallback(() => {\n      setColorPaletteUI({\n        showSketcher: false,\n        colorRangeConfig: {custom: false}\n      });\n    }, [setColorPaletteUI]);\n\n    const _onApply = useCallback(\n      e => onSelectColorRange(customPalette, e),\n      [customPalette, onSelectColorRange]\n    );\n\n    const _onSelectPalette = useCallback(\n      (colorPalette, e) => {\n        const newColorRange = updateColorRangeBySelectedPalette(selectedColorRange, colorPalette, {\n          steps,\n          reversed\n        });\n\n        onSelectColorRange(newColorRange, e);\n      },\n      [selectedColorRange, reversed, steps, onSelectColorRange]\n    );\n    return (\n      <StyledColorRangeSelector>\n        <StyledColorConfig>\n          {(colorRangeConfig.custom ? ['custom'] : Object.keys(colorRangeConfig)).map(key =>\n            CONFIG_SETTINGS[key] ? (\n              <PaletteConfig\n                key={key}\n                prop={key}\n                label={CONFIG_SETTINGS[key].label || key}\n                config={CONFIG_SETTINGS[key]}\n                value={colorRangeConfig[key]}\n                onChange={_updateConfig}\n                disabled={\n                  CONFIG_SETTINGS[key].disabled\n                    ? CONFIG_SETTINGS[key].disabled(selectedColorRange)\n                    : false\n                }\n                reason={CONFIG_SETTINGS[key].reason}\n              />\n            ) : null\n          )}\n        </StyledColorConfig>\n        {colorRangeConfig.custom ? (\n          <>\n            <StyledColorPalette>\n              <ColorPalettePanel colors={customPalette.colors} />\n            </StyledColorPalette>\n            <CustomPalette\n              customPalette={customPalette}\n              showSketcher={showSketcher}\n              onApply={_onApply}\n              setColorPaletteUI={setColorPaletteUI}\n              onCancel={_onCustomPaletteCancel}\n            />\n          </>\n        ) : (\n          <div className=\"color-palette__group\">\n            {filteredColorPalettes.map((colorPalette, i) => (\n              <ColorPaletteItem\n                key={`${colorPalette.name}-${i}`}\n                colorPalette={colorPalette}\n                selectedColorRange={selectedColorRange}\n                onSelect={_onSelectPalette}\n                reversed={reversed}\n                steps={steps}\n              />\n            ))}\n          </div>\n        )}\n      </StyledColorRangeSelector>\n    );\n  };\n\n  ColorRangeSelector.defaultProps = {\n    colorPalettes: KEPLER_COLOR_PALETTES,\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    onSelectColorRange: () => {},\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    setColorPaletteUI: () => {}\n  };\n\n  return ColorRangeSelector;\n}\n\nexport const PaletteConfig: React.FC<PaletteConfigProps> = ({\n  prop,\n  label,\n  value,\n  config: {type, options},\n  onChange,\n  disabled,\n  reason\n}) => {\n  const updateSelect = useCallback(val => onChange({key: prop, value: val}), [onChange, prop]);\n  const updateSwitch = useCallback(\n    () => onChange({key: prop, value: !value}),\n    [onChange, prop, value]\n  );\n\n  return (\n    <StyledPaletteConfig className=\"color-palette__config\" onClick={e => e.stopPropagation()}>\n      <div className=\"color-palette__config__label\">\n        <PanelLabel>\n          <FormattedMessage id={`color.${label}`} />\n        </PanelLabel>\n      </div>\n      <div\n        className=\"color-palette__config__select\"\n        data-tip\n        data-for={`color-range-config-${prop}`}\n      >\n        {type === 'select' && (\n          <ItemSelector\n            selectedItems={value}\n            options={options}\n            multiSelect={false}\n            searchable={false}\n            onChange={updateSelect}\n            disabled={disabled}\n            inputTheme=\"secondary\"\n            displayOption={displayOption}\n            getOptionValue={getOptionValue}\n          />\n        )}\n        {type === 'switch' && (\n          <Switch\n            checked={Boolean(value)}\n            id={`${label}-toggle`}\n            onChange={updateSwitch}\n            disabled={disabled}\n            secondary\n          />\n        )}\n        {disabled && reason ? (\n          <Tooltip id={`color-range-config-${prop}`} place=\"right\">\n            <div style={{maxWidth: '214px'}}>\n              <FormattedMessage id={reason} />\n            </div>\n          </Tooltip>\n        ) : null}\n      </div>\n    </StyledPaletteConfig>\n  );\n};\nconst StyledColorRange = styled.div.attrs({\n  className: 'color-palette-outer'\n})`\n  padding: 0 8px;\n  :hover {\n    background-color: ${props => props.theme.panelBackgroundHover};\n    cursor: pointer;\n  }\n`;\n\ntype ColorPaletteItemProps = {\n  reversed?: boolean;\n  selected?: ColorRange;\n  colorPalette: ColorPalette;\n  selectedColorRange: ColorRange;\n  onSelect: (colorPalette: ColorPalette, e: MouseEvent) => void;\n  steps: number;\n};\n\nexport const ColorPaletteItem: React.FC<ColorPaletteItemProps> = ({\n  colorPalette,\n  steps,\n  selectedColorRange,\n  onSelect,\n  reversed\n}) => {\n  const colors = useMemo(() => colorPalette.colors(steps), [colorPalette, steps]);\n  const onClick = useCallback(e => onSelect(colorPalette, e), [colorPalette, onSelect]);\n  return (\n    <StyledColorRange onClick={onClick}>\n      <ColorPalettePanel\n        colors={colors}\n        isReversed={reversed}\n        isSelected={colorPalette.name === selectedColorRange.name}\n      />\n    </StyledColorRange>\n  );\n};\n\nexport default ColorRangeSelectorFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,36 @@
+import React from 'react';
+import { ColorRange } from '@kepler.gl/constants';
+import { Layer, VisualChannelDomain } from '@kepler.gl/layers';
+import { ColorUI, Field } from '@kepler.gl/types';
+import ColorBreaksPanelFactory, { ColorBreaksPanelProps } from './color-breaks-panel';
+import { SetColorUIFunc } from './custom-palette';
+import { KeplerTable } from '@kepler.gl/table';
+export declare type ScaleOption = {
+    label: string;
+    value: string;
+};
+export declare type OnSelectFunc = (v: string, visConfg?: Record<string, any>) => void;
+export declare type ContextProps = ColorBreaksPanelProps;
+export declare type ColorScaleSelectorProps = {
+    layer: Layer;
+    field: Field;
+    dataset: KeplerTable;
+    scaleType: string;
+    domain: VisualChannelDomain;
+    range: ColorRange;
+    onSelect: OnSelectFunc;
+    setColorUI: SetColorUIFunc;
+    colorUIConfig: ColorUI;
+    options: ScaleOption[];
+    disabled?: boolean;
+    selectedItems: ScaleOption[];
+    multiSelect: boolean;
+    searchable: boolean;
+    displayOption: string;
+    getOptionValue: string;
+};
+declare function ColorScaleSelectorFactory(ColorBreaksPanel: ReturnType<typeof ColorBreaksPanelFactory>): React.FC<ColorScaleSelectorProps>;
+declare namespace ColorScaleSelectorFactory {
+    var deps: (typeof ColorBreaksPanelFactory)[];
+}
+export default ColorScaleSelectorFactory;

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

@@ -0,0 +1,186 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _components = require("@kepler.gl/components");
+var _constants = require("@kepler.gl/constants");
+var _utils = require("@kepler.gl/utils");
+var _colorBreaksPanel = _interopRequireDefault(require("./color-breaks-panel"));
+var _dropdownSelect = _interopRequireDefault(require("../../common/item-selector/dropdown-select"));
+var _excluded = ["layer", "field", "dataset", "onSelect", "scaleType", "domain", "range", "setColorUI", "colorUIConfig"],
+  _excluded2 = ["colorMap"];
+var _templateObject, _templateObject2, _templateObject3, _templateObject4; // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var DropdownPropContext = /*#__PURE__*/_react["default"].createContext({});
+var POPPER_OPTIONS = {
+  modifiers: [
+  // zero offsets since they are already added in VerticalToolbar
+  {
+    name: 'offset',
+    options: {
+      offset: [0, 0]
+    }
+  }]
+};
+var DropdownBottom = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  border-top: 1px solid\n    ", ";\n"])), function (props) {
+  return props.light ? props.theme.dropdownListBorderTopLT : props.theme.dropdownListBorderTop;
+});
+var StyledScaleSelectDropdown = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  box-shadow: ", ";\n  .list-selector {\n    box-shadow: none;\n    border-top: 0;\n  }\n  .list__item {\n    padding: 4px 9px;\n  }\n"])), function (props) {
+  return props.theme.dropdownListShadow;
+});
+var DropdownWrapper = _styledComponents["default"].div(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ", ";\n  position: absolute;\n  margin-top: ", "px;\n"])), function (props) {
+  return props.theme.dropdownWrapperZ;
+}, function (props) {
+  return props.theme.dropdownWapperMargin;
+});
+var StyledColorScaleSelector = _styledComponents["default"].div(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  position: relative;\n  .typeahead {\n    // adds padding to bottom of dropdown\n    margin-bottom: 40px;\n  }\n  [data-tippy-root] {\n    width: 100%;\n  }\n"])));
+function hideTippy(tippyInstance) {
+  if (tippyInstance) {
+    tippyInstance.hide();
+  }
+}
+ColorScaleSelectorFactory.deps = [_colorBreaksPanel["default"]];
+function ColorScaleSelectorFactory(ColorBreaksPanel) {
+  var ColorScaleSelectDropdown = function ColorScaleSelectDropdown(props) {
+    return /*#__PURE__*/_react["default"].createElement(StyledScaleSelectDropdown, null, /*#__PURE__*/_react["default"].createElement(_components.DropdownList, props), /*#__PURE__*/_react["default"].createElement(DropdownPropContext.Consumer, null, function (context) {
+      return /*#__PURE__*/_react["default"].createElement(DropdownBottom, null, /*#__PURE__*/_react["default"].createElement(ColorBreaksPanel, context));
+    }));
+  };
+  var ColorScaleSelector = function ColorScaleSelector(_ref) {
+    var _colorUIConfig$colorR;
+    var layer = _ref.layer,
+      field = _ref.field,
+      dataset = _ref.dataset,
+      onSelect = _ref.onSelect,
+      scaleType = _ref.scaleType,
+      domain = _ref.domain,
+      range = _ref.range,
+      setColorUI = _ref.setColorUI,
+      colorUIConfig = _ref.colorUIConfig,
+      dropdownSelectProps = (0, _objectWithoutProperties2["default"])(_ref, _excluded);
+    var displayOption = _components.Accessor.generateOptionToStringFor(dropdownSelectProps.displayOption);
+    var getOptionValue = (0, _react.useMemo)(function () {
+      return _components.Accessor.generateOptionToStringFor(dropdownSelectProps.getOptionValue);
+    }, [dropdownSelectProps.getOptionValue]);
+    var _useState = (0, _react.useState)(),
+      _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+      tippyInstance = _useState2[0],
+      setTippyInstance = _useState2[1];
+    var isEditingColorBreaks = colorUIConfig === null || colorUIConfig === void 0 || (_colorUIConfig$colorR = colorUIConfig.colorRangeConfig) === null || _colorUIConfig$colorR === void 0 ? void 0 : _colorUIConfig$colorR.customBreaks;
+    var colorScale = (0, _react.useMemo)(function () {
+      return (0, _utils.getLayerColorScale)({
+        range: range,
+        domain: domain,
+        scaleType: scaleType,
+        layer: layer
+      });
+    }, [range, domain, scaleType, layer]);
+    var colorBreaks = (0, _react.useMemo)(function () {
+      return colorScale ? (0, _utils.getLegendOfScale)({
+        scale: colorScale,
+        scaleType: scaleType,
+        fieldType: field.type
+      }) : null;
+    }, [colorScale, scaleType, field.type]);
+    var onSelectScale = (0, _react.useCallback)(function (val) {
+      // highlight selected option
+      if (getOptionValue(val) === _constants.SCALE_TYPES.custom) {
+        // update custom breaks
+        var customPalette = {
+          name: 'color.customPalette',
+          type: 'custom',
+          category: 'Custom',
+          colors: range.colors,
+          colorMap: range.colorMap ? range.colorMap : colorBreaks ? (0, _utils.colorBreaksToColorMap)(colorBreaks) : undefined
+        };
+        setColorUI({
+          showColorChart: true,
+          colorRangeConfig: {
+            customBreaks: true
+          },
+          customPalette: customPalette
+        });
+        onSelect(_constants.SCALE_TYPES.custom, customPalette);
+      } else {
+        // not custom
+        if (isEditingColorBreaks) {
+          setColorUI({
+            colorRangeConfig: {
+              customBreaks: false
+            }
+          });
+        }
+        if ((0, _utils.hasColorMap)(range)) {
+          // remove custom breaks
+          // eslint-disable-next-line no-unused-vars
+          var _ = range.colorMap,
+            newRange = (0, _objectWithoutProperties2["default"])(range, _excluded2);
+          onSelect(getOptionValue(val), newRange);
+        } else {
+          onSelect(getOptionValue(val));
+        }
+      }
+    }, [setColorUI, onSelect, range, getOptionValue, isEditingColorBreaks, colorBreaks]);
+    var onApply = (0, _react.useCallback)(function () {
+      onSelect(_constants.SCALE_TYPES.custom, colorUIConfig.customPalette);
+      hideTippy(tippyInstance);
+    }, [onSelect, colorUIConfig.customPalette, tippyInstance]);
+    var onCancel = (0, _react.useCallback)(function () {
+      hideTippy(tippyInstance);
+    }, [tippyInstance]);
+    var isCustomBreaks = scaleType === _constants.SCALE_TYPES.custom;
+    return /*#__PURE__*/_react["default"].createElement(DropdownPropContext.Provider, {
+      value: {
+        setColorUI: setColorUI,
+        colorField: field,
+        dataset: dataset,
+        colorUIConfig: colorUIConfig,
+        colorBreaks: colorBreaks,
+        isCustomBreaks: isCustomBreaks,
+        onScaleChange: onSelect,
+        onApply: onApply,
+        onCancel: onCancel
+      }
+    }, /*#__PURE__*/_react["default"].createElement(StyledColorScaleSelector, null, /*#__PURE__*/_react["default"].createElement(_components.LazyTippy, {
+      trigger: "click",
+      placement: "bottom-start",
+      appendTo: "parent",
+      interactive: true,
+      hideOnClick: !isEditingColorBreaks,
+      onCreate: setTippyInstance,
+      popperOptions: POPPER_OPTIONS,
+      render: function render(attrs) {
+        return /*#__PURE__*/_react["default"].createElement(DropdownWrapper, attrs, !dropdownSelectProps.disabled && /*#__PURE__*/_react["default"].createElement(_components.Typeahead, (0, _extends2["default"])({}, dropdownSelectProps, {
+          displayOption: displayOption
+          // @ts-ignore
+          ,
+          getOptionValue: getOptionValue,
+          onOptionSelected: onSelectScale,
+          customListComponent: ColorScaleSelectDropdown,
+          searchable: false,
+          showOptionsWhenEmpty: true
+        })));
+      }
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      className: "dropdown-select"
+    }, /*#__PURE__*/_react["default"].createElement(_dropdownSelect["default"], (0, _extends2["default"])({}, dropdownSelectProps, {
+      displayOption: displayOption,
+      value: dropdownSelectProps.selectedItems[0]
+    }))))));
+  };
+  return ColorScaleSelector;
+}
+var _default = exports["default"] = ColorScaleSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_styledComponents","_interopRequireDefault","_components","_constants","_utils","_colorBreaksPanel","_dropdownSelect","_excluded","_excluded2","_templateObject","_templateObject2","_templateObject3","_templateObject4","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","DropdownPropContext","React","createContext","POPPER_OPTIONS","modifiers","name","options","offset","DropdownBottom","styled","div","_taggedTemplateLiteral2","props","light","theme","dropdownListBorderTopLT","dropdownListBorderTop","StyledScaleSelectDropdown","dropdownListShadow","DropdownWrapper","dropdownWrapperZ","dropdownWapperMargin","StyledColorScaleSelector","hideTippy","tippyInstance","hide","ColorScaleSelectorFactory","deps","ColorBreaksPanelFactory","ColorBreaksPanel","ColorScaleSelectDropdown","createElement","DropdownList","Consumer","context","ColorScaleSelector","_ref","_colorUIConfig$colorR","layer","field","dataset","onSelect","scaleType","domain","range","setColorUI","colorUIConfig","dropdownSelectProps","_objectWithoutProperties2","displayOption","Accessor","generateOptionToStringFor","getOptionValue","useMemo","_useState","useState","_useState2","_slicedToArray2","setTippyInstance","isEditingColorBreaks","colorRangeConfig","customBreaks","colorScale","getLayerColorScale","colorBreaks","getLegendOfScale","scale","fieldType","type","onSelectScale","useCallback","val","SCALE_TYPES","custom","customPalette","category","colors","colorMap","colorBreaksToColorMap","undefined","showColorChart","hasColorMap","_","newRange","onApply","onCancel","isCustomBreaks","Provider","value","colorField","onScaleChange","LazyTippy","trigger","placement","appendTo","interactive","hideOnClick","onCreate","popperOptions","render","attrs","disabled","Typeahead","_extends2","onOptionSelected","customListComponent","searchable","showOptionsWhenEmpty","className","selectedItems","_default","exports"],"sources":["../../../src/side-panel/layer-panel/color-scale-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo, useState} from 'react';\nimport styled from 'styled-components';\n\nimport {Accessor, DropdownList, LazyTippy, Typeahead} from '@kepler.gl/components';\nimport {ColorRange, SCALE_TYPES} from '@kepler.gl/constants';\nimport {Layer, VisualChannelDomain} from '@kepler.gl/layers';\nimport {ColorUI, Field, NestedPartial} from '@kepler.gl/types';\nimport {colorBreaksToColorMap, getLayerColorScale, getLegendOfScale, hasColorMap} from '@kepler.gl/utils';\nimport ColorBreaksPanelFactory, {ColorBreaksPanelProps} from './color-breaks-panel';\nimport {SetColorUIFunc} from './custom-palette';\nimport DropdownSelect from '../../common/item-selector/dropdown-select';\nimport {KeplerTable} from '@kepler.gl/table';\nimport type {Instance as TippyInstance} from 'tippy.js';\n\nexport type ScaleOption = {\n  label: string;\n  value: string;\n};\nexport type OnSelectFunc = (v: string, visConfg?: Record<string, any>) => void;\n\nexport type ContextProps = ColorBreaksPanelProps;\n\nexport type ColorScaleSelectorProps = {\n  layer: Layer;\n  field: Field;\n  dataset: KeplerTable;\n  scaleType: string;\n  domain: VisualChannelDomain;\n  range: ColorRange;\n  onSelect: OnSelectFunc;\n  setColorUI: SetColorUIFunc;\n  colorUIConfig: ColorUI;\n  options: ScaleOption[];\n  disabled?: boolean;\n  selectedItems: ScaleOption[];\n  multiSelect: boolean;\n  searchable: boolean;\n  displayOption: string;\n  getOptionValue: string;\n};\n\nconst DropdownPropContext = React.createContext({});\nconst POPPER_OPTIONS = {\n  modifiers: [\n    // zero offsets since they are already added in VerticalToolbar\n    {name: 'offset', options: {offset: [0, 0]}}\n  ]\n};\n\nconst DropdownBottom = styled.div<{light?: boolean}>`\n  border-top: 1px solid\n    ${props =>\n      props.light ? props.theme.dropdownListBorderTopLT : props.theme.dropdownListBorderTop};\n`;\n\nconst StyledScaleSelectDropdown = styled.div`\n  box-shadow: ${props => props.theme.dropdownListShadow};\n  .list-selector {\n    box-shadow: none;\n    border-top: 0;\n  }\n  .list__item {\n    padding: 4px 9px;\n  }\n`;\nconst DropdownWrapper = styled.div`\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ${props => props.theme.dropdownWrapperZ};\n  position: absolute;\n  margin-top: ${props => props.theme.dropdownWapperMargin}px;\n`;\n\nconst StyledColorScaleSelector = styled.div`\n  position: relative;\n  .typeahead {\n    // adds padding to bottom of dropdown\n    margin-bottom: 40px;\n  }\n  [data-tippy-root] {\n    width: 100%;\n  }\n`;\n\nfunction hideTippy(tippyInstance) {\n  if (tippyInstance) {\n    tippyInstance.hide();\n  }\n}\nColorScaleSelectorFactory.deps = [ColorBreaksPanelFactory];\n\nfunction ColorScaleSelectorFactory(\n  ColorBreaksPanel: ReturnType<typeof ColorBreaksPanelFactory>\n): React.FC<ColorScaleSelectorProps> {\n  const ColorScaleSelectDropdown = props => (\n    <StyledScaleSelectDropdown>\n      <DropdownList {...props} />\n      <DropdownPropContext.Consumer>\n        {(context: any) => (\n          <DropdownBottom>\n            <ColorBreaksPanel {...context} />\n          </DropdownBottom>\n        )}\n      </DropdownPropContext.Consumer>\n    </StyledScaleSelectDropdown>\n  );\n\n  const ColorScaleSelector: React.FC<ColorScaleSelectorProps> = ({\n    layer,\n    field,\n    dataset,\n    onSelect,\n    scaleType,\n    domain,\n    range,\n    setColorUI,\n    colorUIConfig,\n    ...dropdownSelectProps\n  }) => {\n    const displayOption = Accessor.generateOptionToStringFor(dropdownSelectProps.displayOption);\n    const getOptionValue = useMemo(\n      () => Accessor.generateOptionToStringFor(dropdownSelectProps.getOptionValue),\n      [dropdownSelectProps.getOptionValue]\n    );\n    const [tippyInstance, setTippyInstance] = useState<TippyInstance>();\n    const isEditingColorBreaks = colorUIConfig?.colorRangeConfig?.customBreaks;\n    const colorScale = useMemo(\n      () =>\n        getLayerColorScale({\n          range,\n          domain,\n          scaleType,\n          layer\n        }),\n      [range, domain, scaleType, layer]\n    );\n\n    const colorBreaks = useMemo(\n      () =>\n        colorScale ? getLegendOfScale({scale: colorScale, scaleType, fieldType: field.type}) : null,\n      [colorScale, scaleType, field.type]\n    );\n\n    const onSelectScale = useCallback(\n      val => {\n        // highlight selected option\n        if (getOptionValue(val) === SCALE_TYPES.custom) {\n          // update custom breaks\n          const customPalette: NestedPartial<ColorRange> = {\n            name: 'color.customPalette',\n            type: 'custom',\n            category: 'Custom',\n            colors: range.colors,\n            colorMap: range.colorMap\n              ? range.colorMap\n              : colorBreaks\n              ? colorBreaksToColorMap(colorBreaks)\n              : undefined\n          };\n          setColorUI({\n            showColorChart: true,\n            colorRangeConfig: {\n              customBreaks: true\n            },\n            customPalette\n          });\n          onSelect(SCALE_TYPES.custom, customPalette);\n        } else {\n          // not custom\n          if (isEditingColorBreaks) {\n            setColorUI({\n              colorRangeConfig: {\n                customBreaks: false\n              }\n            });\n          }\n          if (hasColorMap(range)) {\n            // remove custom breaks\n            // eslint-disable-next-line no-unused-vars\n            const {colorMap: _, ...newRange} = range;\n            onSelect(getOptionValue(val), newRange);\n          } else {\n            onSelect(getOptionValue(val));\n          }\n        }\n      },\n      [setColorUI, onSelect, range, getOptionValue, isEditingColorBreaks, colorBreaks]\n    );\n\n    const onApply = useCallback(() => {\n      onSelect(SCALE_TYPES.custom, colorUIConfig.customPalette);\n      hideTippy(tippyInstance);\n    }, [onSelect, colorUIConfig.customPalette, tippyInstance]);\n\n    const onCancel = useCallback(() => {\n      hideTippy(tippyInstance);\n    }, [tippyInstance]);\n\n    const isCustomBreaks = scaleType === SCALE_TYPES.custom;\n\n    return (\n      <DropdownPropContext.Provider\n        value={{\n          setColorUI,\n          colorField: field,\n          dataset,\n          colorUIConfig,\n          colorBreaks,\n          isCustomBreaks,\n          onScaleChange: onSelect,\n          onApply,\n          onCancel\n        }}\n      >\n        <StyledColorScaleSelector>\n          <LazyTippy\n            trigger=\"click\"\n            placement=\"bottom-start\"\n            appendTo=\"parent\"\n            interactive={true}\n            hideOnClick={!isEditingColorBreaks}\n            onCreate={setTippyInstance}\n            popperOptions={POPPER_OPTIONS}\n            render={attrs => (\n              <DropdownWrapper {...attrs}>\n                {/*@ts-ignore*/}\n                {!dropdownSelectProps.disabled && (\n                  <Typeahead\n                    {...dropdownSelectProps}\n                    displayOption={displayOption}\n                    // @ts-ignore\n                    getOptionValue={getOptionValue}\n                    onOptionSelected={onSelectScale}\n                    customListComponent={ColorScaleSelectDropdown}\n                    searchable={false}\n                    showOptionsWhenEmpty\n                  />\n                )}\n              </DropdownWrapper>\n            )}\n          >\n            <div className=\"dropdown-select\">\n              {/*@ts-ignore*/}\n              <DropdownSelect\n                {...dropdownSelectProps}\n                displayOption={displayOption}\n                value={dropdownSelectProps.selectedItems[0]}\n              />\n            </div>\n          </LazyTippy>\n        </StyledColorScaleSelector>\n      </DropdownPropContext.Provider>\n    );\n  };\n  return ColorScaleSelector;\n}\nexport default ColorScaleSelectorFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,34 @@
+import { ColorRange } from '@kepler.gl/constants';
+import { ColorUI, NestedPartial, RGBAColor, RGBColor } from '@kepler.gl/types';
+import { ComponentType } from 'react';
+import RangeSliderFactory from '../../common/range-slider';
+import ColorRangeSelectorFactory from './color-range-selector';
+declare type ColorSelectorInputProps = {
+    active: boolean;
+    disabled?: boolean;
+    inputTheme?: string;
+};
+export declare type ColorSet = {
+    selectedColor: RGBColor | RGBAColor | ColorRange;
+    setColor: (v: RGBColor | RGBAColor | ColorRange) => void;
+    isRange?: boolean;
+    label?: string;
+};
+declare type ColorSelectorProps = {
+    colorSets: ColorSet[];
+    colorUI?: ColorUI;
+    inputTheme?: string;
+    disabled?: boolean;
+    useOpacity?: boolean;
+    setColorUI?: (newConfig: NestedPartial<ColorUI>) => void;
+};
+export declare const ColorBlock: import("styled-components").StyledComponent<"div", any, {
+    backgroundcolor: RGBColor;
+}, never>;
+export declare const ColorSelectorInput: import("styled-components").StyledComponent<"div", any, ColorSelectorInputProps, never>;
+export declare const InputBoxContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+declare function ColorSelectorFactory(ColorRangeSelector: any, RangeSlider: any): ComponentType<ColorSelectorProps>;
+declare namespace ColorSelectorFactory {
+    var deps: (typeof RangeSliderFactory | typeof ColorRangeSelectorFactory)[];
+}
+export default ColorSelectorFactory;