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

package/dist/esm/side-panel/layer-panel/color-palette-preset.js

@@ -0,0 +1,40 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { range } from 'd3-array';
+import { ColorsByTheme } from '@kepler.gl/constants';
+var PALETTE_HEIGHT = '8px';
+var ROWS = 22;
+var StyledColorPalette = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  padding: 12px;\n\n  &:hover {\n    cursor: pointer;\n  }\n"])));
+var StyledColorColumn = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-grow: 1;\n  flex-direction: column;\n  justify-content: space-between;\n"])));
+var StyledColorBlock = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  flex-grow: 1;\n  height: ", ";\n  border-width: 1px;\n  border-style: solid;\n"])), PALETTE_HEIGHT);
+var PresetColorPalette = function PresetColorPalette(_ref) {
+  var themes = _ref.themes,
+    onSelectColor = _ref.onSelectColor,
+    selectedColor = _ref.selectedColor;
+  return /*#__PURE__*/React.createElement(StyledColorPalette, null, themes.map(function (theme) {
+    return /*#__PURE__*/React.createElement(StyledColorColumn, {
+      key: theme,
+      className: "single-color-palette__column"
+    }, range(1, ROWS + 1, 1).map(function (key) {
+      return /*#__PURE__*/React.createElement(StyledColorBlock, {
+        className: "single-color-palette__block",
+        style: {
+          backgroundColor: ColorsByTheme[theme][key],
+          borderColor: selectedColor === ColorsByTheme[theme][key].toUpperCase() ? 'white' : ColorsByTheme[theme][key]
+        },
+        key: "".concat(theme, "_").concat(key),
+        selected: selectedColor === ColorsByTheme[theme][key].toUpperCase(),
+        onClick: function onClick(e) {
+          return onSelectColor(ColorsByTheme[theme][key], e);
+        }
+      });
+    }));
+  }));
+};
+export default PresetColorPalette;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,67 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import classnames from 'classnames';
+var PaletteWrapper = styled.div.attrs({
+  className: 'color-range-palette__inner'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  border-radius: 2px;\n  display: flex;\n  flex-direction: row;\n  flex-grow: 1;\n  justify-content: space-between;\n  overflow: hidden;\n"])));
+var PaletteContainer = styled.div.attrs(function (props) {
+  return {
+    className: classnames('color-range-palette', props.className)
+  };
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-grow: 1;\n  border-width: ", ";\n  border-style: solid;\n  border-color: ", ";\n  padding: ", ";\n  border-radius: 4px;\n"])), function (props) {
+  return props.$isColorChart ? '0px' : '1px';
+}, function (props) {
+  return props.$isSelected ? '#FFFFFF' : 'transparent';
+}, function (props) {
+  return props.$isColorChart ? '0px' : '4px';
+});
+var StyledColorBlock = styled.div.attrs({
+  className: 'color-range-palette__block'
+})(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  flex-grow: 1;\n"])));
+var ColorPalette = function ColorPalette(_ref) {
+  var _ref$colors = _ref.colors,
+    colors = _ref$colors === void 0 ? [] : _ref$colors,
+    _ref$height = _ref.height,
+    height = _ref$height === void 0 ? 10 : _ref$height,
+    _ref$colorWidths = _ref.colorWidths,
+    colorWidths = _ref$colorWidths === void 0 ? null : _ref$colorWidths,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    _ref$isSelected = _ref.isSelected,
+    isSelected = _ref$isSelected === void 0 ? false : _ref$isSelected,
+    _ref$isReversed = _ref.isReversed,
+    isReversed = _ref$isReversed === void 0 ? false : _ref$isReversed;
+  var paletteWrapperStyle = useMemo(function () {
+    return {
+      height: height,
+      transform: "scale(".concat(isReversed ? -1 : 1, ", 1)")
+    };
+  }, [height, isReversed]);
+  return /*#__PURE__*/React.createElement(PaletteContainer, {
+    className: className,
+    $isSelected: isSelected,
+    $isColorChart: Boolean(colorWidths)
+  }, /*#__PURE__*/React.createElement(PaletteWrapper, {
+    style: paletteWrapperStyle
+  }, colors.map(function (color, index) {
+    return colorWidths && colorWidths[index] ? /*#__PURE__*/React.createElement(StyledColorBlock, {
+      key: "".concat(color, "-").concat(index),
+      style: {
+        backgroundColor: String(color),
+        width: colorWidths[index]
+      }
+    }) : /*#__PURE__*/React.createElement(StyledColorBlock, {
+      key: "".concat(color, "-").concat(index),
+      style: {
+        backgroundColor: String(color)
+      }
+    });
+  })));
+};
+export default ColorPalette;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,236 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import styled from 'styled-components';
+import { KEPLER_COLOR_PALETTES, PALETTE_TYPES } from '@kepler.gl/constants';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { hasColorMap, updateColorRangeBySelectedPalette, paletteIsSteps, paletteIsType, paletteIsColorBlindSafe } from '@kepler.gl/utils';
+import ItemSelector from '../../common/item-selector/item-selector';
+import { PanelLabel, Tooltip } from '../../common/styled-components';
+import Switch from '../../common/switch';
+import ColorPalettePanel from './color-palette';
+import CustomPaletteFactory from './custom-palette';
+import { capitalizeFirstLetter } from '@kepler.gl/utils';
+import { range } from 'd3-array';
+// @ts-ignore cant concat 'all' to PALETTE_TYPES values
+export var ALL_TYPES = Object.values(PALETTE_TYPES).concat(['all']);
+var MAX_STEPS = 20;
+var ALL_STEPS = range(2, MAX_STEPS + 1, 1);
+var StyledColorConfig = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  padding: 12px 12px 0 12px;\n"])));
+var StyledColorRangeSelector = styled.div.attrs({
+  className: 'color-range-selector'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  padding-bottom: 12px;\n"])));
+var StyledColorPalette = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  padding: 0 8px 8px 8px;\n"])));
+var StyledPaletteConfig = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\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 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 capitalizeFirstLetter(d);
+};
+var getOptionValue = function getOptionValue(d) {
+  return d;
+};
+var noop = function noop() {
+  // do nothing
+};
+ColorRangeSelectorFactory.deps = [CustomPaletteFactory];
+function ColorRangeSelectorFactory(CustomPalette) {
+  var ColorRangeSelector = function ColorRangeSelector(_ref) {
+    var _ref$colorPalettes = _ref.colorPalettes,
+      colorPalettes = _ref$colorPalettes === void 0 ? KEPLER_COLOR_PALETTES : _ref$colorPalettes,
+      colorPaletteUI = _ref.colorPaletteUI,
+      _ref$setColorPaletteU = _ref.setColorPaletteUI,
+      setColorPaletteUI = _ref$setColorPaletteU === void 0 ? noop : _ref$setColorPaletteU,
+      _ref$onSelectColorRan = _ref.onSelectColorRange,
+      onSelectColorRange = _ref$onSelectColorRan === void 0 ? noop : _ref$onSelectColorRan,
+      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 = useMemo(function () {
+      var _colorPalettes$filter;
+      return (_colorPalettes$filter = colorPalettes === null || colorPalettes === void 0 ? void 0 : colorPalettes.filter(function (palette) {
+        return paletteIsType(palette, type) && paletteIsSteps(palette, steps) && paletteIsColorBlindSafe(palette, colorBlindSafe);
+      })) !== null && _colorPalettes$filter !== void 0 ? _colorPalettes$filter : [];
+    }, [colorPalettes, colorBlindSafe, steps, type]);
+    var _updateConfig = useCallback(function (_ref2) {
+      var key = _ref2.key,
+        value = _ref2.value;
+      setColorPaletteUI({
+        colorRangeConfig: _defineProperty({}, key, value)
+      });
+    }, [setColorPaletteUI]);
+    var _onCustomPaletteCancel = useCallback(function () {
+      setColorPaletteUI({
+        showSketcher: false,
+        colorRangeConfig: {
+          custom: false
+        }
+      });
+    }, [setColorPaletteUI]);
+    var _onApply = useCallback(function (e) {
+      return onSelectColorRange(customPalette, e);
+    }, [customPalette, onSelectColorRange]);
+    var _onSelectPalette = useCallback(function (colorPalette, e) {
+      var newColorRange = updateColorRangeBySelectedPalette(selectedColorRange, colorPalette, {
+        steps: steps,
+        reversed: reversed
+      });
+      onSelectColorRange(newColorRange, e);
+    }, [selectedColorRange, reversed, steps, onSelectColorRange]);
+    return /*#__PURE__*/React.createElement(StyledColorRangeSelector, null, /*#__PURE__*/React.createElement(StyledColorConfig, null, (colorRangeConfig.custom ? ['custom'] : Object.keys(colorRangeConfig)).map(function (key) {
+      return CONFIG_SETTINGS[key] ? /*#__PURE__*/React.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.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledColorPalette, null, /*#__PURE__*/React.createElement(ColorPalettePanel, {
+      colors: customPalette.colors
+    })), /*#__PURE__*/React.createElement(CustomPalette, {
+      customPalette: customPalette,
+      showSketcher: showSketcher,
+      onApply: _onApply,
+      setColorPaletteUI: setColorPaletteUI,
+      onCancel: _onCustomPaletteCancel
+    })) : /*#__PURE__*/React.createElement("div", {
+      className: "color-palette__group"
+    }, filteredColorPalettes.map(function (colorPalette, i) {
+      return /*#__PURE__*/React.createElement(ColorPaletteItem, {
+        key: "".concat(colorPalette.name, "-").concat(i),
+        colorPalette: colorPalette,
+        selectedColorRange: selectedColorRange,
+        onSelect: _onSelectPalette,
+        reversed: reversed,
+        steps: steps
+      });
+    })));
+  };
+  return ColorRangeSelector;
+}
+export var 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 = useCallback(function (val) {
+    return onChange({
+      key: prop,
+      value: val
+    });
+  }, [onChange, prop]);
+  var updateSwitch = useCallback(function () {
+    return onChange({
+      key: prop,
+      value: !value
+    });
+  }, [onChange, prop, value]);
+  return /*#__PURE__*/React.createElement(StyledPaletteConfig, {
+    className: "color-palette__config",
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    }
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "color-palette__config__label"
+  }, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: "color.".concat(label)
+  }))), /*#__PURE__*/React.createElement("div", {
+    className: "color-palette__config__select",
+    "data-tip": true,
+    "data-for": "color-range-config-".concat(prop)
+  }, type === 'select' && /*#__PURE__*/React.createElement(ItemSelector, {
+    selectedItems: value,
+    options: options,
+    multiSelect: false,
+    searchable: false,
+    onChange: updateSelect,
+    disabled: disabled,
+    inputTheme: "secondary",
+    displayOption: displayOption,
+    getOptionValue: getOptionValue
+  }), type === 'switch' && /*#__PURE__*/React.createElement(Switch, {
+    checked: Boolean(value),
+    id: "".concat(label, "-toggle"),
+    onChange: updateSwitch,
+    disabled: disabled,
+    secondary: true
+  }), disabled && reason ? /*#__PURE__*/React.createElement(Tooltip, {
+    id: "color-range-config-".concat(prop),
+    place: "right"
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      maxWidth: '214px'
+    }
+  }, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: reason
+  }))) : null));
+};
+var StyledColorRange = styled.div.attrs({
+  className: 'color-palette-outer'
+})(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  padding: 0 8px;\n  &:hover {\n    background-color: ", ";\n    cursor: pointer;\n  }\n"])), function (props) {
+  return props.theme.panelBackgroundHover;
+});
+export var ColorPaletteItem = function ColorPaletteItem(_ref4) {
+  var colorPalette = _ref4.colorPalette,
+    steps = _ref4.steps,
+    selectedColorRange = _ref4.selectedColorRange,
+    onSelect = _ref4.onSelect,
+    reversed = _ref4.reversed;
+  var colors = useMemo(function () {
+    return colorPalette.colors(steps);
+  }, [colorPalette, steps]);
+  var onClick = useCallback(function (e) {
+    return onSelect(colorPalette, e);
+  }, [colorPalette, onSelect]);
+  return /*#__PURE__*/React.createElement(StyledColorRange, {
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement(ColorPalettePanel, {
+    colors: colors,
+    isReversed: reversed,
+    isSelected: colorPalette.name === selectedColorRange.name
+  }));
+};
+export default ColorRangeSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","styled","KEPLER_COLOR_PALETTES","PALETTE_TYPES","FormattedMessage","hasColorMap","updateColorRangeBySelectedPalette","paletteIsSteps","paletteIsType","paletteIsColorBlindSafe","ItemSelector","PanelLabel","Tooltip","Switch","ColorPalettePanel","CustomPaletteFactory","capitalizeFirstLetter","range","ALL_TYPES","Object","values","concat","MAX_STEPS","ALL_STEPS","StyledColorConfig","div","_templateObject","_taggedTemplateLiteral","StyledColorRangeSelector","attrs","className","_templateObject2","StyledColorPalette","_templateObject3","StyledPaletteConfig","_templateObject4","CONFIG_SETTINGS","type","options","steps","disabled","colorRange","reason","reversed","colorBlindSafe","custom","label","displayOption","d","getOptionValue","noop","ColorRangeSelectorFactory","deps","CustomPalette","ColorRangeSelector","_ref","_ref$colorPalettes","colorPalettes","colorPaletteUI","_ref$setColorPaletteU","setColorPaletteUI","_ref$onSelectColorRan","onSelectColorRange","selectedColorRange","customPalette","showSketcher","colorRangeConfig","filteredColorPalettes","_colorPalettes$filter","filter","palette","_updateConfig","_ref2","key","value","_defineProperty","_onCustomPaletteCancel","_onApply","e","_onSelectPalette","colorPalette","newColorRange","createElement","keys","map","PaletteConfig","prop","config","onChange","Fragment","colors","onApply","onCancel","i","ColorPaletteItem","name","onSelect","_ref3","_ref3$config","updateSelect","val","updateSwitch","onClick","stopPropagation","id","selectedItems","multiSelect","searchable","inputTheme","checked","Boolean","secondary","place","style","maxWidth","StyledColorRange","_templateObject5","props","theme","panelBackgroundHover","_ref4","isReversed","isSelected"],"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, ColorPalette} from '@kepler.gl/constants';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {ColorRange, 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;\nconst noop = () => {\n  // do nothing\n};\n\nColorRangeSelectorFactory.deps = [CustomPaletteFactory];\nfunction ColorRangeSelectorFactory(\n  CustomPalette: ReturnType<typeof CustomPaletteFactory>\n): React.FC<ColorRangeSelectorProps> {\n  const ColorRangeSelector: React.FC<ColorRangeSelectorProps> = ({\n    colorPalettes = KEPLER_COLOR_PALETTES,\n    colorPaletteUI,\n    setColorPaletteUI = noop,\n    onSelectColorRange = noop,\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  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":[]}