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

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

@@ -0,0 +1,783 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _excluded = ["className", "children"];
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject0, _templateObject1, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17, _templateObject18;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import classnames from 'classnames';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import uniq from 'lodash/uniq';
+import { DndContext, closestCenter, KeyboardSensor, PointerSensor, useSensor, useSensors } from '@dnd-kit/core';
+import { SortableContext, useSortable, verticalListSortingStrategy } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import styled, { css } from 'styled-components';
+import Portaled from '../../common/portaled';
+import { Tooltip } from '../../common/styled-components';
+import Typeahead from '../../common/item-selector/typeahead';
+import ChickletedInput from '../../common/item-selector/chickleted-input';
+import DropdownList, { ListItem } from '../../common/item-selector/dropdown-list';
+import { shouldForwardProp } from '../../common/styled-components';
+import { toArray } from '@kepler.gl/common-utils';
+import { KeyEvent } from '@kepler.gl/constants';
+import { addCategoricalValuesToColorMap, addCustomPaletteColor, colorMapToCategoricalColorBreaks, colorMapToColorBreaks, isNumericColorBreaks, resetCategoricalColorMapByIndex, removeCategoricalValueFromColorMap, removeCustomPaletteColor, selectRestCategoricalColorMapByIndex, sortCustomPaletteColor, updateCustomPaletteColor } from '@kepler.gl/utils';
+import { Add, Trash, VertDots } from '../../common/icons';
+import { Button, Input } from '../../common/styled-components';
+import CustomPicker from './custom-picker';
+
+/**
+ * EditableColorRange
+ */
+
+var defaultActionIcons = {
+  "delete": Trash,
+  sort: VertDots,
+  add: Add
+};
+var dragHandleActive = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  .layer__drag-handle {\n    color: ", ";\n    opacity: 1;\n    cursor: move;\n  }\n"])), function (props) {
+  return props.theme.textColorHl;
+});
+export var ColorPaletteItem = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  padding-top: 2px;\n  padding-bottom: 2px;\n  z-index: ", ";\n  justify-content: space-between;\n\n  .custom-palette-input__left {\n    display: flex;\n    align-items: center;\n  }\n\n  .custom-palette-input__right {\n    display: flex;\n    align-items: center;\n    padding-right: 6px;\n  }\n\n  &:not(.sorting):not(.disabled) {\n    &:hover {\n      background-color: ", ";\n      ", ";\n    }\n  }\n\n  &.sorting-colors {\n    background-color: ", ";\n    ", ";\n  }\n"])), function (props) {
+  return props.theme.dropdownWrapperZ + 1;
+}, function (props) {
+  return props.theme.panelBackgroundHover;
+}, dragHandleActive, function (props) {
+  return props.theme.panelBackgroundHover;
+}, dragHandleActive);
+var StyledDragHandle = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  opacity: 0;\n"])));
+var StyledAction = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  color: ", ";\n  svg {\n    &:hover {\n      color: ", ";\n    }\n  }\n\n  margin-left: 4px;\n  &:hover {\n    cursor: pointer;\n  }\n"])), function (props) {
+  return props.theme.subtextColor;
+}, function (props) {
+  return props.theme.subtextColorActive;
+});
+export var DividerLine = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  height: 1px;\n  background-color: ", ";\n  margin-top: 8px;\n"])), function (props) {
+  return props.theme.dropdownListBorderTop;
+});
+export var ColorSwatch = styled.div.attrs({
+  className: 'custom-palette__swatch'
+})(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  background-color: ", ";\n  width: 32px;\n  height: 18px;\n  display: inline-block;\n  &:hover {\n    box-shadow: ", ";\n    cursor: pointer;\n  }\n"])), function (props) {
+  return props.color;
+}, function (props) {
+  return props.theme.boxShadow;
+});
+var StyledButtonContainer = styled.div(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  margin-top: 11px;\n  display: flex;\n  direction: rtl;\n  padding: 0 12px;\n"])));
+var StyledAddStepContainer = styled.div(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  margin-top: 11px;\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n  padding: 0 12px;\n  color: ", ";\n  .addcolor {\n    margin-top: 4px;\n  }\n"])), function (props) {
+  return props.theme.inputColor;
+});
+var StyledInput = styled(Input).withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n  width: ", ";\n  text-align: ", ";\n  pointer-events: ", ";\n  font-size: 10px;\n  padding-left: 4px;\n  padding-right: 4px;\n"])), function (props) {
+  var _props$width;
+  return (_props$width = props.width) !== null && _props$width !== void 0 ? _props$width : '100%';
+}, function (props) {
+  var _props$textAlign;
+  return (_props$textAlign = props.textAlign) !== null && _props$textAlign !== void 0 ? _props$textAlign : 'end';
+}, function (props) {
+  return props.disabled ? 'none' : 'all';
+});
+var InputText = styled.div.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject0 || (_templateObject0 = _taggedTemplateLiteral(["\n  ", ";\n  background-color: transparent;\n  border-color: transparent;\n  width: ", ";\n  text-align: ", ";\n  font-size: 10px;\n  padding-left: 4px;\n  padding-right: 4px;\n\n  &:hover {\n    cursor: auto;\n    background-color: transparent;\n    border-color: transparent;\n  }\n"])), function (props) {
+  return props.theme.input;
+}, function (props) {
+  var _props$width2;
+  return (_props$width2 = props.width) !== null && _props$width2 !== void 0 ? _props$width2 : '100%';
+}, function (props) {
+  var _props$textAlign2;
+  return (_props$textAlign2 = props.textAlign) !== null && _props$textAlign2 !== void 0 ? _props$textAlign2 : 'end';
+});
+var SortableItem = function SortableItem(_ref) {
+  var id = _ref.id,
+    children = _ref.children,
+    isSorting = _ref.isSorting;
+  var _useSortable = useSortable({
+      id: id
+    }),
+    attributes = _useSortable.attributes,
+    listeners = _useSortable.listeners,
+    setNodeRef = _useSortable.setNodeRef,
+    transform = _useSortable.transform,
+    transition = _useSortable.transition,
+    isDragging = _useSortable.isDragging;
+  var style = {
+    transform: CSS.Transform.toString(transform),
+    transition: transition,
+    zIndex: isDragging ? 1 : 0
+  };
+  return /*#__PURE__*/React.createElement(ColorPaletteItem, _extends({
+    ref: setNodeRef,
+    style: style,
+    className: classnames('custom-palette__sortable-items', {
+      sorting: isSorting || isDragging
+    })
+  }, attributes), children(listeners));
+};
+var WrappedSortableContainer = function WrappedSortableContainer(_ref2) {
+  var children = _ref2.children,
+    className = _ref2.className,
+    onSortEnd = _ref2.onSortEnd,
+    onSortStart = _ref2.onSortStart;
+  var sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor));
+  return /*#__PURE__*/React.createElement(DndContext, {
+    sensors: sensors,
+    collisionDetection: closestCenter,
+    onDragEnd: onSortEnd,
+    onDragStart: onSortStart
+  }, /*#__PURE__*/React.createElement(SortableContext, {
+    items: React.Children.map(children, function (_, index) {
+      return "".concat(index);
+    }) || [],
+    strategy: verticalListSortingStrategy
+  }, /*#__PURE__*/React.createElement("div", {
+    className: className
+  }, children)));
+};
+var DragHandle = function DragHandle(_ref3) {
+  var className = _ref3.className,
+    children = _ref3.children,
+    listeners = _objectWithoutProperties(_ref3, _excluded);
+  return /*#__PURE__*/React.createElement(StyledDragHandle, _extends({
+    className: className
+  }, listeners), children);
+};
+export var ColorPaletteInput = function ColorPaletteInput(_ref4) {
+  var value = _ref4.value,
+    onChange = _ref4.onChange,
+    id = _ref4.id,
+    width = _ref4.width,
+    textAlign = _ref4.textAlign,
+    editable = _ref4.editable;
+  var _useState = useState(value),
+    _useState2 = _slicedToArray(_useState, 2),
+    stateValue = _useState2[0],
+    setValue = _useState2[1];
+  var inputRef = useRef(null);
+  useEffect(function () {
+    setValue(value);
+  }, [value]);
+  var onKeyDown = useCallback(function (e) {
+    switch (e.keyCode) {
+      case KeyEvent.DOM_VK_ENTER:
+      case KeyEvent.DOM_VK_RETURN:
+        onChange(stateValue);
+        if (inputRef !== null) {
+          // @ts-ignore
+          inputRef === null || inputRef === void 0 || inputRef.current.blur();
+        }
+        break;
+      default:
+        break;
+    }
+  }, [onChange, stateValue]);
+  var _onChange = useCallback(function (e) {
+    return setValue(e.target.value);
+  }, [setValue]);
+  var onBlur = useCallback(function () {
+    return onChange(stateValue);
+  }, [onChange, stateValue]);
+  return editable ? /*#__PURE__*/React.createElement(StyledInput, {
+    ref: inputRef,
+    className: "custom-palette-hex__input",
+    value: stateValue,
+    onChange: _onChange,
+    onBlur: onBlur,
+    onKeyDown: onKeyDown,
+    id: id,
+    width: width,
+    textAlign: textAlign,
+    secondary: true
+  }) : /*#__PURE__*/React.createElement(InputText, {
+    className: "custom-palette-hex__input__text",
+    width: width,
+    textAlign: textAlign
+  }, value);
+};
+var Dash = styled.div(_templateObject1 || (_templateObject1 = _taggedTemplateLiteral(["\n  width: 6px;\n  border-top: 1px solid ", ";\n  margin-left: 4px;\n  margin-right: 4px;\n"])), function (props) {
+  return props.theme.subtextColor;
+});
+var StyledRangeInput = styled.div(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["\n  display: flex;\n  justify-content: flex-end;\n  align-items: center;\n  margin-left: 12px;\n"])));
+var StyledColorHexInput = styled.div(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["\n  margin-left: 12px;\n"])));
+export var EditableColorRange = function EditableColorRange(_ref5) {
+  var item = _ref5.item,
+    isLast = _ref5.isLast,
+    index = _ref5.index,
+    editColorMap = _ref5.editColorMap,
+    editable = _ref5.editable;
+  var hasInputs = Array.isArray(item === null || item === void 0 ? void 0 : item.inputs);
+  var leftInput = hasInputs ? item.inputs[0] : undefined;
+  var rightInput = hasInputs ? item.inputs[1] : undefined;
+  var noMinBound = !Number.isFinite(leftInput) && index === 0;
+  var noMaxBound = !Number.isFinite(rightInput) && isLast;
+  var onChangeLeft = useCallback(function (val) {
+    if (editable && editColorMap) editColorMap(parseFloat(val), index - 1);
+  }, [editColorMap, index, editable]);
+  var onChangeRight = useCallback(function (val) {
+    if (editable && editColorMap) editColorMap(parseFloat(val), index);
+  }, [editColorMap, index, editable]);
+  return /*#__PURE__*/React.createElement(StyledRangeInput, null, /*#__PURE__*/React.createElement(ColorPaletteInput, {
+    value: noMinBound ? 'Less' : String(leftInput !== null && leftInput !== void 0 ? leftInput : ''),
+    id: "color-palette-input-".concat(index, "-left"),
+    width: "54px",
+    textAlign: "end",
+    editable: noMinBound ? false : editable,
+    onChange: onChangeLeft
+  }), /*#__PURE__*/React.createElement(Dash, null), /*#__PURE__*/React.createElement(ColorPaletteInput, {
+    value: noMaxBound ? 'More' : String(rightInput !== null && rightInput !== void 0 ? rightInput : ''),
+    id: "color-palette-input-".concat(index, "-right"),
+    width: "54px",
+    textAlign: "end",
+    onChange: onChangeRight,
+    editable: noMaxBound ? false : editable
+  }));
+};
+export var AddColorStop = function AddColorStop(_ref6) {
+  var onColorAdd = _ref6.onColorAdd,
+    IconComponent = _ref6.IconComponent;
+  return /*#__PURE__*/React.createElement(StyledAction, {
+    onClick: onColorAdd,
+    className: "addcolor"
+  }, /*#__PURE__*/React.createElement(IconComponent, {
+    height: "14px"
+  }));
+};
+export var DeleteColorStop = function DeleteColorStop(_ref7) {
+  var onColorDelete = _ref7.onColorDelete,
+    IconComponent = _ref7.IconComponent;
+  return /*#__PURE__*/React.createElement(StyledAction, {
+    onClick: onColorDelete,
+    className: "trashbin"
+  }, /*#__PURE__*/React.createElement(IconComponent, {
+    height: "14px"
+  }));
+};
+export var CustomPaletteInput = function CustomPaletteInput(_ref8) {
+  var index = _ref8.index,
+    isSorting = _ref8.isSorting,
+    color = _ref8.color,
+    colorBreaks = _ref8.colorBreaks,
+    inputColorHex = _ref8.inputColorHex,
+    editColorMapValue = _ref8.editColorMapValue,
+    _ref8$actionIcons = _ref8.actionIcons,
+    actionIcons = _ref8$actionIcons === void 0 ? defaultActionIcons : _ref8$actionIcons,
+    disableAppend = _ref8.disableAppend,
+    disableDelete = _ref8.disableDelete,
+    onDelete = _ref8.onDelete,
+    onAdd = _ref8.onAdd,
+    onToggleSketcher = _ref8.onToggleSketcher;
+  var onClickSwtach = useCallback(function () {
+    return onToggleSketcher(index);
+  }, [onToggleSketcher, index]);
+  var onColorInput = useCallback(function (v) {
+    return inputColorHex(index, v);
+  }, [inputColorHex, index]);
+  var onColorDelete = useCallback(function () {
+    return onDelete(index);
+  }, [onDelete, index]);
+  var onColorAdd = useCallback(function () {
+    return onAdd(index);
+  }, [onAdd, index]);
+  var showHexInput = !colorBreaks;
+  return /*#__PURE__*/React.createElement(SortableItem, {
+    id: "".concat(index),
+    isSorting: isSorting
+  }, function (listeners) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      className: "custom-palette-input__left"
+    }, /*#__PURE__*/React.createElement(DragHandle, _extends({
+      className: "layer__drag-handle"
+    }, listeners), /*#__PURE__*/React.createElement(actionIcons.sort, {
+      height: "20px"
+    })), /*#__PURE__*/React.createElement(ColorSwatch, {
+      color: color,
+      onClick: onClickSwtach
+    }), showHexInput ? /*#__PURE__*/React.createElement(StyledColorHexInput, null, /*#__PURE__*/React.createElement(ColorPaletteInput, {
+      value: color.toUpperCase(),
+      onChange: onColorInput,
+      id: "input-layer-label-".concat(index),
+      editable: true,
+      textAlign: "left",
+      width: "70px"
+    })) : null, colorBreaks && index < colorBreaks.length && isNumericColorBreaks(colorBreaks) ? /*#__PURE__*/React.createElement(EditableColorRange, {
+      item: colorBreaks[index],
+      isLast: index === colorBreaks.length - 1,
+      index: index,
+      editColorMap: editColorMapValue,
+      editable: true
+    }) : null), /*#__PURE__*/React.createElement("div", {
+      className: "custom-palette-input__right"
+    }, !disableAppend ? /*#__PURE__*/React.createElement(AddColorStop, {
+      onColorAdd: onColorAdd,
+      IconComponent: actionIcons.add
+    }) : null, !disableDelete ? /*#__PURE__*/React.createElement(DeleteColorStop, {
+      onColorDelete: onColorDelete,
+      IconComponent: actionIcons["delete"]
+    }) : null));
+  });
+};
+var StyledCategoricalValuePickerWrapper = styled.div.attrs({
+  className: 'categorical-value-picker'
+})(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["\n  width: 150px;\n  color: ", ";\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-end;\n  column-gap: 8px;\n  align-items: center;\n  cursor: pointer;\n"])), function (props) {
+  return props.theme.inputColor;
+});
+var StyledCategoricalValuePicker = styled.div(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["\n  width: fit-content;\n  font-size: 11px;\n  border-bottom: ", ";\n  cursor: pointer;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  max-width: 100px;\n"])), function (props) {
+  return props.noBorder ? '' : '1px dashed';
+});
+var DropdownValuesWrapper = styled.div(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ", ";\n  width: ", "px;\n"])), function (props) {
+  return props.theme.dropdownWrapperZ;
+}, function (props) {
+  return props.width;
+});
+var SelectedValuesWrapper = styled(DropdownValuesWrapper)(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["\n  width: ", "px;\n  max-height: ", "px;\n  overflow: auto;\n\n  .custom-palette-chickleted-input {\n    padding: 8px;\n    background-color: ", ";\n  }\n"])), function (props) {
+  return props.width;
+}, function (props) {
+  return props.height;
+}, function (props) {
+  return props.theme.dropdownWrapperZ;
+});
+var StyledDropdownHeader = styled.div(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  color: ", ";\n  padding: 0 8px;\n  font-size: 10px;\n\n  .button {\n    margin: 0;\n    padding: 0;\n    width: fit-content;\n  }\n"])), function (props) {
+  return props.theme.inputColor;
+});
+var StyledTooltipContent = styled.div(_templateObject17 || (_templateObject17 = _taggedTemplateLiteral(["\n  padding: 8px;\n  width: 150px;\n  box-sizing: border-box;\n  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);\n\n  div {\n    overflow: hidden;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n  }\n"])));
+var NUMBER_VALUES_IN_TOOLTIP = 10;
+var CategoricalSelectorContext = /*#__PURE__*/React.createContext({
+  onSelectRest: function onSelectRest() {
+    return null;
+  },
+  onReset: function onReset() {
+    return null;
+  }
+});
+
+// Categorical values dropdownlist:
+// extending DropdownList and adding 'Select the Rest' and 'Reset' buttons
+var ModifiedDropdownList = /*#__PURE__*/function (_DropdownList) {
+  function ModifiedDropdownList(props) {
+    _classCallCheck(this, ModifiedDropdownList);
+    return _callSuper(this, ModifiedDropdownList, [props]);
+  }
+  _inherits(ModifiedDropdownList, _DropdownList);
+  return _createClass(ModifiedDropdownList, [{
+    key: "render",
+    value: function render() {
+      var _this = this;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(CategoricalSelectorContext.Consumer, null, function (context) {
+        return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledDropdownHeader, null, /*#__PURE__*/React.createElement(Button, {
+          link: true,
+          size: "smal",
+          onClick: context.onSelectRest
+        }, "Select the Rest"), /*#__PURE__*/React.createElement(Button, {
+          link: true,
+          size: "smal",
+          onClick: context.onReset
+        }, "Reset")), /*#__PURE__*/React.createElement(DividerLine, null), /*#__PURE__*/React.createElement(DropdownList, _this.props));
+      }));
+    }
+  }]);
+}(DropdownList);
+// Categorical values selector for editing categorical values
+export var CategoricalSelector = function CategoricalSelector(_ref9) {
+  var index = _ref9.index,
+    selectedValues = _ref9.selectedValues,
+    allValues = _ref9.allValues,
+    addColorMapValue = _ref9.addColorMapValue,
+    removeColorMapValue = _ref9.removeColorMapValue,
+    resetColorMapValue = _ref9.resetColorMapValue,
+    selectRestColorMapValue = _ref9.selectRestColorMapValue,
+    _ref9$editable = _ref9.editable,
+    editable = _ref9$editable === void 0 ? true : _ref9$editable;
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    showTypeahead = _useState4[0],
+    setShowTypeahead = _useState4[1];
+  var onOptionSelected = useCallback(function (value) {
+    var previousSelected = toArray(selectedValues);
+    var items = uniq(previousSelected.concat(toArray(value)));
+    addColorMapValue === null || addColorMapValue === void 0 || addColorMapValue(items, index);
+  }, [selectedValues, index, addColorMapValue]);
+  var onOpenDropdown = useCallback(function () {
+    setShowTypeahead(true);
+  }, []);
+  var onCloseDropdown = useCallback(function () {
+    setShowTypeahead(false);
+  }, []);
+  var onRemoveItem = useCallback(function (value) {
+    removeColorMapValue === null || removeColorMapValue === void 0 || removeColorMapValue(value, index);
+  }, [index, removeColorMapValue]);
+  var onReset = useCallback(function () {
+    resetColorMapValue === null || resetColorMapValue === void 0 || resetColorMapValue(index);
+    setShowTypeahead(false);
+    return null;
+  }, [resetColorMapValue, index]);
+  var onSelectRest = useCallback(function () {
+    selectRestColorMapValue === null || selectRestColorMapValue === void 0 || selectRestColorMapValue(index);
+    setShowTypeahead(false);
+    return null;
+  }, [selectRestColorMapValue, index]);
+  return /*#__PURE__*/React.createElement(StyledCategoricalValuePickerWrapper, null, editable && /*#__PURE__*/React.createElement(Add, {
+    height: "12px",
+    onClick: onOpenDropdown
+  }), /*#__PURE__*/React.createElement(StyledCategoricalValuePicker, {
+    noBorder: selectedValues.length === 0 || !editable,
+    onClick: onOpenDropdown,
+    "data-tip": true,
+    "data-for": "category-values-".concat(index)
+  }, selectedValues.length === 0 ? 'Add Value' : selectedValues.length === 1 ? selectedValues[0] : "".concat(selectedValues.length, " selected"), selectedValues.length > 1 && /*#__PURE__*/React.createElement(Tooltip, {
+    id: "category-values-".concat(index),
+    place: "top",
+    interactive: true
+  }, /*#__PURE__*/React.createElement(StyledTooltipContent, null, selectedValues.slice(0, NUMBER_VALUES_IN_TOOLTIP).map(function (value, i) {
+    return /*#__PURE__*/React.createElement("div", {
+      key: i
+    }, value);
+  }), selectedValues.length > NUMBER_VALUES_IN_TOOLTIP && /*#__PURE__*/React.createElement("div", null, "...")))), editable && /*#__PURE__*/React.createElement(Portaled, {
+    left: 0,
+    top: 0,
+    isOpened: showTypeahead,
+    onClose: onCloseDropdown
+  }, selectedValues.length > 1 && /*#__PURE__*/React.createElement(SelectedValuesWrapper, {
+    width: 250,
+    height: 200
+  }, /*#__PURE__*/React.createElement(ChickletedInput, {
+    className: 'custom-palette-chickleted-input',
+    selectedItems: selectedValues,
+    placeholder: '',
+    removeItem: onRemoveItem,
+    onClick: function onClick() {
+      return null;
+    },
+    CustomChickletComponent: null
+  })), /*#__PURE__*/React.createElement(DropdownValuesWrapper, {
+    width: 250
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      position: 'relative'
+    }
+  }, /*#__PURE__*/React.createElement(CategoricalSelectorContext.Provider, {
+    value: {
+      onReset: onReset,
+      onSelectRest: onSelectRest
+    }
+  }, /*#__PURE__*/React.createElement(Typeahead, {
+    customClasses: {
+      results: 'list-selector',
+      input: 'typeahead__input',
+      listItem: 'list__item',
+      listAnchor: 'list__item__anchor'
+    },
+    options: allValues
+    // add safe string casting for the Typeahead, so fuzzy search never receives non-strings, preventing the toLowerCase crash
+    ,
+    displayOption: function displayOption(o) {
+      return String(o !== null && o !== void 0 ? o : '');
+    },
+    filterOption: function filterOption(input, o) {
+      return String(o !== null && o !== void 0 ? o : '').includes(String(input !== null && input !== void 0 ? input : ''));
+    },
+    placeholder: 'Search',
+    onOptionSelected: onOptionSelected,
+    customListComponent: ModifiedDropdownList,
+    customListItemComponent: ListItem,
+    searchable: true,
+    showOptionsWhenEmpty: true,
+    selectedItems: selectedValues
+  }))))));
+};
+export var CategoricalCustomPaletteInput = function CategoricalCustomPaletteInput(_ref0) {
+  var index = _ref0.index,
+    isSorting = _ref0.isSorting,
+    color = _ref0.color,
+    colorMap = _ref0.colorMap,
+    _ref0$actionIcons = _ref0.actionIcons,
+    actionIcons = _ref0$actionIcons === void 0 ? defaultActionIcons : _ref0$actionIcons,
+    onDelete = _ref0.onDelete,
+    disableDelete = _ref0.disableDelete,
+    onToggleSketcher = _ref0.onToggleSketcher,
+    addColorMapValue = _ref0.addColorMapValue,
+    removeColorMapValue = _ref0.removeColorMapValue,
+    resetColorMapValue = _ref0.resetColorMapValue,
+    selectRestColorMapValue = _ref0.selectRestColorMapValue,
+    allValues = _ref0.allValues;
+  var selectedValues = useMemo(function () {
+    if (!colorMap || !colorMap[index]) return [];
+    var value = colorMap[index][0];
+    var values = Array.isArray(value) ? value : value !== null ? [value] : [];
+    return values;
+  }, [colorMap, index]);
+  var onClickSwtach = useCallback(function () {
+    return onToggleSketcher(index);
+  }, [onToggleSketcher, index]);
+  var onColorDelete = useCallback(function () {
+    return onDelete(index);
+  }, [onDelete, index]);
+  return /*#__PURE__*/React.createElement(SortableItem, {
+    id: "".concat(index),
+    isSorting: isSorting
+  }, function (listeners) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      className: "custom-palette-input__left"
+    }, /*#__PURE__*/React.createElement(DragHandle, _extends({
+      className: "layer__drag-handle"
+    }, listeners), /*#__PURE__*/React.createElement(actionIcons.sort, {
+      height: "20px"
+    })), /*#__PURE__*/React.createElement(ColorSwatch, {
+      color: color,
+      onClick: onClickSwtach
+    }), colorMap && colorMap[index] && /*#__PURE__*/React.createElement(CategoricalSelector, {
+      selectedValues: selectedValues,
+      allValues: allValues,
+      addColorMapValue: addColorMapValue,
+      removeColorMapValue: removeColorMapValue,
+      resetColorMapValue: resetColorMapValue,
+      selectRestColorMapValue: selectRestColorMapValue,
+      index: index
+    })), /*#__PURE__*/React.createElement("div", {
+      className: "custom-palette-input__right"
+    }, !disableDelete ? /*#__PURE__*/React.createElement(DeleteColorStop, {
+      onColorDelete: onColorDelete,
+      IconComponent: actionIcons["delete"]
+    }) : null));
+  });
+};
+export var BottomAction = function BottomAction(_ref1) {
+  var onCancel = _ref1.onCancel,
+    onConfirm = _ref1.onConfirm;
+  return /*#__PURE__*/React.createElement(StyledButtonContainer, null, /*#__PURE__*/React.createElement(Button, {
+    className: "confirm-apply__button",
+    small: true,
+    onClick: onConfirm
+  }, "Confirm"), /*#__PURE__*/React.createElement(Button, {
+    link: true,
+    small: true,
+    onClick: onCancel
+  }, "Cancel"));
+};
+var StyledCustomPalette = styled.div.attrs({
+  className: 'custom-palette'
+})(_templateObject18 || (_templateObject18 = _taggedTemplateLiteral(["\n  margin-top: 8px;\n"])));
+function CustomPaletteFactory() {
+  var CustomPalette = function CustomPalette(_ref10) {
+    var ordinalDomain = _ref10.ordinalDomain,
+      customPalette = _ref10.customPalette,
+      setColorPaletteUI = _ref10.setColorPaletteUI,
+      showSketcher = _ref10.showSketcher,
+      _ref10$actionIcons = _ref10.actionIcons,
+      actionIcons = _ref10$actionIcons === void 0 ? defaultActionIcons : _ref10$actionIcons,
+      onCancel = _ref10.onCancel,
+      onApply = _ref10.onApply;
+    var _useState5 = useState(false),
+      _useState6 = _slicedToArray(_useState5, 2),
+      isSorting = _useState6[0],
+      setIsSorting = _useState6[1];
+    var colors = customPalette.colors,
+      colorMap = customPalette.colorMap;
+    var colorBreaks = useMemo(function () {
+      return colorMap ? customPalette.type === 'custom' ? colorMapToColorBreaks(colorMap) : colorMapToCategoricalColorBreaks(colorMap) : null;
+    }, [customPalette.type, colorMap]);
+    var onPickerUpdate = useCallback(function (color) {
+      if (color && Number.isFinite(showSketcher)) {
+        var newCustomPalette = updateCustomPaletteColor(customPalette, Number(showSketcher), color.hex);
+        setColorPaletteUI({
+          customPalette: newCustomPalette
+        });
+      }
+    }, [customPalette, showSketcher, setColorPaletteUI]);
+    var onToggleSketcher = useCallback(function (val) {
+      setColorPaletteUI({
+        showSketcher: val
+      });
+    }, [setColorPaletteUI]);
+    var onDelete = useCallback(function (index) {
+      var newCustomPalette = removeCustomPaletteColor(customPalette, index);
+      setColorPaletteUI({
+        customPalette: newCustomPalette
+      });
+    }, [customPalette, setColorPaletteUI]);
+    var onAdd = useCallback(function (index) {
+      // add color at the end
+      var newCustomPalette = addCustomPaletteColor(customPalette, index);
+      setColorPaletteUI({
+        customPalette: newCustomPalette
+      });
+    }, [customPalette, setColorPaletteUI]);
+    var onAddCategoricalStep = useCallback(function () {
+      onAdd(colors.length - 1);
+    }, [colors.length, onAdd]);
+    var onSwatchClose = useCallback(function () {
+      onToggleSketcher(false);
+    }, [onToggleSketcher]);
+    var onConfirm = useCallback(function (event) {
+      event.stopPropagation();
+      event.preventDefault();
+      onCancel();
+      onApply(event);
+    }, [onCancel, onApply]);
+    var onSortEnd = useCallback(function (event) {
+      var active = event.active,
+        over = event.over;
+      if (over && active.id !== over.id) {
+        var oldIndex = colors.findIndex(function (_, index) {
+          return "".concat(index) === active.id;
+        });
+        var newIndex = colors.findIndex(function (_, index) {
+          return "".concat(index) === over.id;
+        });
+        var newCustomPalette = sortCustomPaletteColor(customPalette, oldIndex, newIndex);
+        setColorPaletteUI({
+          customPalette: newCustomPalette
+        });
+      }
+      setIsSorting(false);
+    }, [colors, customPalette, setIsSorting, setColorPaletteUI]);
+    var onSortStart = useCallback(function () {
+      setIsSorting(true);
+    }, [setIsSorting]);
+    var inputColorHex = useCallback(function (index, value) {
+      var newCustomPalette = updateCustomPaletteColor(customPalette, index, value);
+      // setColors(newColors);
+      setColorPaletteUI({
+        customPalette: newCustomPalette
+      });
+    }, [customPalette, setColorPaletteUI]);
+    var editColorMapValue = useCallback(function (value, index) {
+      if (!customPalette.colorMap) {
+        return;
+      }
+      var newColorMap = customPalette.colorMap.map(function (cm, i) {
+        return i === index ? [value, cm[1]] : cm;
+      });
+
+      // sort the user inputs in case the break values are not ordered
+      var breaks = newColorMap.map(function (cm) {
+        return cm[0];
+      }).slice(0, -1).sort(function (a, b) {
+        return Number(a) - Number(b);
+      }).concat(null);
+      var sortedNewColorMap = newColorMap.map(function (cm, i) {
+        return [breaks[i], cm[1]];
+      });
+      setColorPaletteUI({
+        customPalette: _objectSpread(_objectSpread({}, customPalette), {}, {
+          colorMap: sortedNewColorMap
+        })
+      });
+    }, [setColorPaletteUI, customPalette]);
+
+    // remove a selected category item from a color map
+    var removeCategoricalColorMapValue = useCallback(function (item, index) {
+      if (!colorMap) {
+        return;
+      }
+      setColorPaletteUI({
+        customPalette: _objectSpread(_objectSpread({}, customPalette), {}, {
+          colorMap: removeCategoricalValueFromColorMap(colorMap, item, index)
+        })
+      });
+    }, [setColorPaletteUI, customPalette, colorMap]);
+
+    // add selected categorical items to a color map
+    var addCategoricalColorMapValue = useCallback(function (items, index) {
+      if (!colorMap) {
+        return;
+      }
+      setColorPaletteUI({
+        customPalette: _objectSpread(_objectSpread({}, customPalette), {}, {
+          colorMap: addCategoricalValuesToColorMap(colorMap, items, index)
+        })
+      });
+    }, [setColorPaletteUI, customPalette, colorMap]);
+
+    // reset a color map
+    var resetCategoricalColorMapValue = useCallback(function (index) {
+      if (!colorMap) {
+        return;
+      }
+      setColorPaletteUI({
+        customPalette: _objectSpread(_objectSpread({}, customPalette), {}, {
+          colorMap: resetCategoricalColorMapByIndex(colorMap, index)
+        })
+      });
+    }, [setColorPaletteUI, customPalette, colorMap]);
+
+    // select the rest values for a color map
+    var selectRestCategoricalColorMap = useCallback(function (index) {
+      if (!colorMap) {
+        return;
+      }
+      setColorPaletteUI({
+        customPalette: _objectSpread(_objectSpread({}, customPalette), {}, {
+          colorMap: selectRestCategoricalColorMapByIndex(colorMap, index, ordinalDomain)
+        })
+      });
+    }, [setColorPaletteUI, customPalette, colorMap, ordinalDomain]);
+    return /*#__PURE__*/React.createElement(StyledCustomPalette, null, /*#__PURE__*/React.createElement(WrappedSortableContainer, {
+      className: "custom-palette__sortable-container",
+      onSortEnd: onSortEnd,
+      onSortStart: onSortStart
+    }, colors.map(function (color, index) {
+      return customPalette.type === 'custom' ? /*#__PURE__*/React.createElement(CustomPaletteInput, {
+        key: index,
+        colorBreaks: colorBreaks,
+        index: index,
+        isSorting: isSorting,
+        color: color,
+        inputColorHex: inputColorHex,
+        disableAppend: colors.length >= 20,
+        disableDelete: colors.length <= 2,
+        actionIcons: actionIcons,
+        onAdd: onAdd,
+        onDelete: onDelete,
+        onToggleSketcher: onToggleSketcher,
+        editColorMapValue: editColorMapValue
+      }) : ordinalDomain && /*#__PURE__*/React.createElement(CategoricalCustomPaletteInput, {
+        key: index,
+        colorMap: colorMap,
+        index: index,
+        isSorting: isSorting,
+        color: color,
+        actionIcons: actionIcons,
+        onAdd: onAdd,
+        onDelete: onDelete,
+        disableDelete: colors.length <= 2,
+        onToggleSketcher: onToggleSketcher,
+        addColorMapValue: addCategoricalColorMapValue,
+        removeColorMapValue: removeCategoricalColorMapValue,
+        resetColorMapValue: resetCategoricalColorMapValue,
+        selectRestColorMapValue: selectRestCategoricalColorMap,
+        allValues: ordinalDomain
+      });
+    })), customPalette.type === 'customOrdinal' && /*#__PURE__*/React.createElement(StyledAddStepContainer, null, /*#__PURE__*/React.createElement(AddColorStop, {
+      onColorAdd: onAddCategoricalStep,
+      IconComponent: actionIcons.add
+    }), /*#__PURE__*/React.createElement(Button, {
+      link: true,
+      size: "smal",
+      onClick: onAddCategoricalStep
+    }, "Add Step")), /*#__PURE__*/React.createElement(DividerLine, null), /*#__PURE__*/React.createElement(BottomAction, {
+      onCancel: onCancel,
+      onConfirm: onConfirm
+    }), /*#__PURE__*/React.createElement(Portaled, {
+      isOpened: showSketcher !== false,
+      left: 280,
+      top: -300,
+      onClose: onSwatchClose
+    }, /*#__PURE__*/React.createElement(CustomPicker, {
+      color: colors[Number(showSketcher)],
+      onChange: onPickerUpdate
+    })));
+  };
+  return CustomPalette;
+}
+export default CustomPaletteFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["classnames","React","useCallback","useEffect","useMemo","useRef","useState","uniq","DndContext","closestCenter","KeyboardSensor","PointerSensor","useSensor","useSensors","SortableContext","useSortable","verticalListSortingStrategy","CSS","styled","css","Portaled","Tooltip","Typeahead","ChickletedInput","DropdownList","ListItem","shouldForwardProp","toArray","KeyEvent","addCategoricalValuesToColorMap","addCustomPaletteColor","colorMapToCategoricalColorBreaks","colorMapToColorBreaks","isNumericColorBreaks","resetCategoricalColorMapByIndex","removeCategoricalValueFromColorMap","removeCustomPaletteColor","selectRestCategoricalColorMapByIndex","sortCustomPaletteColor","updateCustomPaletteColor","Add","Trash","VertDots","Button","Input","CustomPicker","defaultActionIcons","sort","add","dragHandleActive","_templateObject","_taggedTemplateLiteral","props","theme","textColorHl","ColorPaletteItem","div","_templateObject2","dropdownWrapperZ","panelBackgroundHover","StyledDragHandle","_templateObject3","StyledAction","_templateObject4","subtextColor","subtextColorActive","DividerLine","_templateObject5","dropdownListBorderTop","ColorSwatch","attrs","className","_templateObject6","color","boxShadow","StyledButtonContainer","_templateObject7","StyledAddStepContainer","_templateObject8","inputColor","StyledInput","withConfig","_templateObject9","_props$width","width","_props$textAlign","textAlign","disabled","InputText","_templateObject0","input","_props$width2","_props$textAlign2","SortableItem","_ref","id","children","isSorting","_useSortable","attributes","listeners","setNodeRef","transform","transition","isDragging","style","Transform","toString","zIndex","createElement","_extends","ref","sorting","WrappedSortableContainer","_ref2","onSortEnd","onSortStart","sensors","collisionDetection","onDragEnd","onDragStart","items","Children","map","_","index","concat","strategy","DragHandle","_ref3","_objectWithoutProperties","_excluded","ColorPaletteInput","_ref4","value","onChange","editable","_useState","_useState2","_slicedToArray","stateValue","setValue","inputRef","onKeyDown","e","keyCode","DOM_VK_ENTER","DOM_VK_RETURN","current","blur","_onChange","target","onBlur","secondary","Dash","_templateObject1","StyledRangeInput","_templateObject10","StyledColorHexInput","_templateObject11","EditableColorRange","_ref5","item","isLast","editColorMap","hasInputs","Array","isArray","inputs","leftInput","undefined","rightInput","noMinBound","Number","isFinite","noMaxBound","onChangeLeft","val","parseFloat","onChangeRight","String","AddColorStop","_ref6","onColorAdd","IconComponent","onClick","height","DeleteColorStop","_ref7","onColorDelete","CustomPaletteInput","_ref8","colorBreaks","inputColorHex","editColorMapValue","_ref8$actionIcons","actionIcons","disableAppend","disableDelete","onDelete","onAdd","onToggleSketcher","onClickSwtach","onColorInput","v","showHexInput","Fragment","toUpperCase","length","StyledCategoricalValuePickerWrapper","_templateObject12","StyledCategoricalValuePicker","_templateObject13","noBorder","DropdownValuesWrapper","_templateObject14","SelectedValuesWrapper","_templateObject15","StyledDropdownHeader","_templateObject16","StyledTooltipContent","_templateObject17","NUMBER_VALUES_IN_TOOLTIP","CategoricalSelectorContext","createContext","onSelectRest","onReset","ModifiedDropdownList","_DropdownList","_classCallCheck","_callSuper","_inherits","_createClass","key","render","_this","Consumer","context","link","size","CategoricalSelector","_ref9","selectedValues","allValues","addColorMapValue","removeColorMapValue","resetColorMapValue","selectRestColorMapValue","_ref9$editable","_useState3","_useState4","showTypeahead","setShowTypeahead","onOptionSelected","previousSelected","onOpenDropdown","onCloseDropdown","onRemoveItem","place","interactive","slice","i","left","top","isOpened","onClose","selectedItems","placeholder","removeItem","CustomChickletComponent","position","Provider","customClasses","results","listItem","listAnchor","options","displayOption","o","filterOption","includes","customListComponent","customListItemComponent","searchable","showOptionsWhenEmpty","CategoricalCustomPaletteInput","_ref0","colorMap","_ref0$actionIcons","values","BottomAction","_ref1","onCancel","onConfirm","small","StyledCustomPalette","_templateObject18","CustomPaletteFactory","CustomPalette","_ref10","ordinalDomain","customPalette","setColorPaletteUI","showSketcher","_ref10$actionIcons","onApply","_useState5","_useState6","setIsSorting","colors","type","onPickerUpdate","newCustomPalette","hex","onAddCategoricalStep","onSwatchClose","event","stopPropagation","preventDefault","active","over","oldIndex","findIndex","newIndex","newColorMap","cm","breaks","a","b","sortedNewColorMap","_objectSpread","removeCategoricalColorMapValue","addCategoricalColorMapValue","resetCategoricalColorMapValue","selectRestCategoricalColorMap"],"sources":["../../../../src/side-panel/layer-panel/custom-palette.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport classnames from 'classnames';\nimport React, {\n  ElementType,\n  PropsWithChildren,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState\n} from 'react';\nimport uniq from 'lodash/uniq';\nimport {\n  DndContext,\n  closestCenter,\n  KeyboardSensor,\n  PointerSensor,\n  useSensor,\n  useSensors,\n  DragEndEvent\n} from '@dnd-kit/core';\nimport {SortableContext, useSortable, verticalListSortingStrategy} from '@dnd-kit/sortable';\nimport {CSS} from '@dnd-kit/utilities';\nimport styled, {css} from 'styled-components';\nimport Portaled from '../../common/portaled';\nimport {Tooltip} from '../../common/styled-components';\nimport Typeahead from '../../common/item-selector/typeahead';\nimport ChickletedInput from '../../common/item-selector/chickleted-input';\nimport DropdownList, {ListItem} from '../../common/item-selector/dropdown-list';\nimport {shouldForwardProp} from '../../common/styled-components';\nimport {toArray} from '@kepler.gl/common-utils';\nimport {KeyEvent} from '@kepler.gl/constants';\nimport {ColorMap, ColorUI, HexColor, NestedPartial} from '@kepler.gl/types';\nimport {\n  addCategoricalValuesToColorMap,\n  addCustomPaletteColor,\n  colorMapToCategoricalColorBreaks,\n  colorMapToColorBreaks,\n  isNumericColorBreaks,\n  resetCategoricalColorMapByIndex,\n  removeCategoricalValueFromColorMap,\n  removeCustomPaletteColor,\n  selectRestCategoricalColorMapByIndex,\n  sortCustomPaletteColor,\n  updateCustomPaletteColor\n} from '@kepler.gl/utils';\nimport {ColorBreak, ColorBreakOrdinal} from '@kepler.gl/utils';\nimport {Add, Trash, VertDots} from '../../common/icons';\nimport {Button, Input} from '../../common/styled-components';\nimport CustomPicker from './custom-picker';\n\nexport type ActionIcons = {\n  delete: ElementType;\n  sort: ElementType;\n  add: ElementType;\n};\n\nexport type EditColorMapFunc = (v: number, i: number) => void;\nexport type SetColorUIFunc = (newConfig: NestedPartial<ColorUI>) => void;\n\n/**\n * EditableColorRange\n */\nexport type EditableColorRangeProps = {\n  item: ColorBreak;\n  isLast: boolean;\n  index: number;\n  editColorMap?: EditColorMapFunc;\n  editable: boolean;\n};\n\nexport type CustomPaletteProps = {\n  customPalette: ColorUI['customPalette'];\n  setColorPaletteUI: SetColorUIFunc;\n  showSketcher: number | boolean;\n  ordinalDomain?: string[] | number[];\n  actionIcons?: ActionIcons;\n  onApply: (e: React.MouseEvent) => void;\n  onCancel: () => void;\n};\n\nexport type CustomPaletteInputProps = {\n  index: number;\n  isSorting: boolean;\n  color: HexColor;\n  colorBreaks: ColorBreakOrdinal[] | ColorBreak[] | null;\n  inputColorHex: (index: number, v: HexColor) => void;\n  editColorMapValue: EditColorMapFunc;\n  actionIcons?: ActionIcons;\n  disableAppend?: boolean;\n  disableDelete?: boolean;\n  onDelete: (index: number) => void;\n  onAdd: (index: number) => void;\n  onToggleSketcher: (index: number) => void;\n};\n\nconst defaultActionIcons = {\n  delete: Trash,\n  sort: VertDots,\n  add: Add\n};\n\nconst dragHandleActive = css`\n  .layer__drag-handle {\n    color: ${props => props.theme.textColorHl};\n    opacity: 1;\n    cursor: move;\n  }\n`;\n\nexport const ColorPaletteItem = styled.div`\n  display: flex;\n  align-items: center;\n  padding-top: 2px;\n  padding-bottom: 2px;\n  z-index: ${props => props.theme.dropdownWrapperZ + 1};\n  justify-content: space-between;\n\n  .custom-palette-input__left {\n    display: flex;\n    align-items: center;\n  }\n\n  .custom-palette-input__right {\n    display: flex;\n    align-items: center;\n    padding-right: 6px;\n  }\n\n  &:not(.sorting):not(.disabled) {\n    &:hover {\n      background-color: ${props => props.theme.panelBackgroundHover};\n      ${dragHandleActive};\n    }\n  }\n\n  &.sorting-colors {\n    background-color: ${props => props.theme.panelBackgroundHover};\n    ${dragHandleActive};\n  }\n`;\n\nconst StyledDragHandle = styled.div`\n  display: flex;\n  align-items: center;\n  opacity: 0;\n`;\n\nconst StyledAction = styled.div`\n  color: ${props => props.theme.subtextColor};\n  svg {\n    &:hover {\n      color: ${props => props.theme.subtextColorActive};\n    }\n  }\n\n  margin-left: 4px;\n  &:hover {\n    cursor: pointer;\n  }\n`;\n\nexport const DividerLine = styled.div`\n  height: 1px;\n  background-color: ${props => props.theme.dropdownListBorderTop};\n  margin-top: 8px;\n`;\n\nexport const ColorSwatch = styled.div.attrs({\n  className: 'custom-palette__swatch'\n})`\n  background-color: ${props => props.color};\n  width: 32px;\n  height: 18px;\n  display: inline-block;\n  &:hover {\n    box-shadow: ${props => props.theme.boxShadow};\n    cursor: pointer;\n  }\n`;\n\nconst StyledButtonContainer = styled.div`\n  margin-top: 11px;\n  display: flex;\n  direction: rtl;\n  padding: 0 12px;\n`;\n\nconst StyledAddStepContainer = styled.div`\n  margin-top: 11px;\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-start;\n  align-items: center;\n  padding: 0 12px;\n  color: ${props => props.theme.inputColor};\n  .addcolor {\n    margin-top: 4px;\n  }\n`;\n\nconst StyledInput = styled(Input).withConfig({shouldForwardProp})<{\n  width: string;\n  textAlign: string;\n}>`\n  width: ${props => props.width ?? '100%'};\n  text-align: ${props => props.textAlign ?? 'end'};\n  pointer-events: ${props => (props.disabled ? 'none' : 'all')};\n  font-size: 10px;\n  padding-left: 4px;\n  padding-right: 4px;\n`;\n\nconst InputText = styled.div.withConfig({shouldForwardProp})<{width: string; textAlign: string}>`\n  ${props => props.theme.input};\n  background-color: transparent;\n  border-color: transparent;\n  width: ${props => props.width ?? '100%'};\n  text-align: ${props => props.textAlign ?? 'end'};\n  font-size: 10px;\n  padding-left: 4px;\n  padding-right: 4px;\n\n  &:hover {\n    cursor: auto;\n    background-color: transparent;\n    border-color: transparent;\n  }\n`;\n\ntype SortableItemProps = {\n  id: string;\n  children: (listeners: any) => React.ReactNode;\n  className?: string;\n  isSorting: boolean;\n};\n\nconst SortableItem = ({id, children, isSorting}: SortableItemProps) => {\n  const {attributes, listeners, setNodeRef, transform, transition, isDragging} = useSortable({id});\n  const style = {\n    transform: CSS.Transform.toString(transform),\n    transition,\n    zIndex: isDragging ? 1 : 0\n  };\n  return (\n    <ColorPaletteItem\n      ref={setNodeRef}\n      style={style}\n      className={classnames('custom-palette__sortable-items', {sorting: isSorting || isDragging})}\n      {...attributes}\n    >\n      {children(listeners)}\n    </ColorPaletteItem>\n  );\n};\n\ntype WrappedSortableContainerProps = {\n  children?: React.ReactNode;\n  className?: string;\n  onSortEnd: (event: DragEndEvent) => void;\n  onSortStart: () => void;\n};\n\nconst WrappedSortableContainer = ({\n  children,\n  className,\n  onSortEnd,\n  onSortStart\n}: WrappedSortableContainerProps) => {\n  const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor));\n  return (\n    <DndContext\n      sensors={sensors}\n      collisionDetection={closestCenter}\n      onDragEnd={onSortEnd}\n      onDragStart={onSortStart}\n    >\n      <SortableContext\n        items={React.Children.map(children, (_, index) => `${index}`) || []}\n        strategy={verticalListSortingStrategy}\n      >\n        <div className={className}>{children}</div>\n      </SortableContext>\n    </DndContext>\n  );\n};\n\ntype DragHandleProps = PropsWithChildren<{className?: string}>;\nconst DragHandle = ({className, children, ...listeners}: DragHandleProps) => (\n  <StyledDragHandle className={className} {...listeners}>\n    {children}\n  </StyledDragHandle>\n);\n\nexport type ColorPaletteInputProps = {\n  value: string | number;\n  onChange: (val: unknown) => void;\n  id: string;\n  width: string;\n  textAlign: string;\n  editable: boolean;\n};\n\nexport const ColorPaletteInput = ({\n  value,\n  onChange,\n  id,\n  width,\n  textAlign,\n  editable\n}: ColorPaletteInputProps) => {\n  const [stateValue, setValue] = useState(value);\n  const inputRef = useRef(null);\n  useEffect(() => {\n    setValue(value);\n  }, [value]);\n\n  const onKeyDown = useCallback(\n    e => {\n      switch (e.keyCode) {\n        case KeyEvent.DOM_VK_ENTER:\n        case KeyEvent.DOM_VK_RETURN:\n          onChange(stateValue);\n          if (inputRef !== null) {\n            // @ts-ignore\n            inputRef?.current.blur();\n          }\n          break;\n        default:\n          break;\n      }\n    },\n    [onChange, stateValue]\n  );\n\n  const _onChange = useCallback(e => setValue(e.target.value), [setValue]);\n  const onBlur = useCallback(() => onChange(stateValue), [onChange, stateValue]);\n\n  return editable ? (\n    <StyledInput\n      ref={inputRef}\n      className=\"custom-palette-hex__input\"\n      value={stateValue}\n      onChange={_onChange}\n      onBlur={onBlur}\n      onKeyDown={onKeyDown}\n      id={id}\n      width={width}\n      textAlign={textAlign}\n      secondary\n    />\n  ) : (\n    <InputText className=\"custom-palette-hex__input__text\" width={width} textAlign={textAlign}>\n      {value}\n    </InputText>\n  );\n};\n\nconst Dash = styled.div`\n  width: 6px;\n  border-top: 1px solid ${props => props.theme.subtextColor};\n  margin-left: 4px;\n  margin-right: 4px;\n`;\n\nconst StyledRangeInput = styled.div`\n  display: flex;\n  justify-content: flex-end;\n  align-items: center;\n  margin-left: 12px;\n`;\n\nconst StyledColorHexInput = styled.div`\n  margin-left: 12px;\n`;\n\nexport const EditableColorRange: React.FC<EditableColorRangeProps> = ({\n  item,\n  isLast,\n  index,\n  editColorMap,\n  editable\n}) => {\n  const hasInputs = Array.isArray(item?.inputs);\n  const leftInput = hasInputs ? item.inputs[0] : undefined;\n  const rightInput = hasInputs ? item.inputs[1] : undefined;\n  const noMinBound = !Number.isFinite(leftInput) && index === 0;\n  const noMaxBound = !Number.isFinite(rightInput) && isLast;\n  const onChangeLeft = useCallback(\n    val => {\n      if (editable && editColorMap) editColorMap(parseFloat(val), index - 1);\n    },\n    [editColorMap, index, editable]\n  );\n  const onChangeRight = useCallback(\n    val => {\n      if (editable && editColorMap) editColorMap(parseFloat(val), index);\n    },\n    [editColorMap, index, editable]\n  );\n\n  return (\n    <StyledRangeInput>\n      <ColorPaletteInput\n        value={noMinBound ? 'Less' : String(leftInput ?? '')}\n        id={`color-palette-input-${index}-left`}\n        width=\"54px\"\n        textAlign=\"end\"\n        editable={noMinBound ? false : editable}\n        onChange={onChangeLeft}\n      />\n      <Dash />\n      <ColorPaletteInput\n        value={noMaxBound ? 'More' : String(rightInput ?? '')}\n        id={`color-palette-input-${index}-right`}\n        width=\"54px\"\n        textAlign=\"end\"\n        onChange={onChangeRight}\n        editable={noMaxBound ? false : editable}\n      />\n    </StyledRangeInput>\n  );\n};\n\nexport const AddColorStop = ({onColorAdd, IconComponent}) => (\n  <StyledAction onClick={onColorAdd} className=\"addcolor\">\n    <IconComponent height=\"14px\" />\n  </StyledAction>\n);\n\nexport const DeleteColorStop = ({onColorDelete, IconComponent}) => (\n  <StyledAction onClick={onColorDelete} className=\"trashbin\">\n    <IconComponent height=\"14px\" />\n  </StyledAction>\n);\n\nexport const CustomPaletteInput: React.FC<CustomPaletteInputProps> = ({\n  index,\n  isSorting,\n  color,\n  colorBreaks,\n  inputColorHex,\n  editColorMapValue,\n  actionIcons = defaultActionIcons,\n  disableAppend,\n  disableDelete,\n  onDelete,\n  onAdd,\n  onToggleSketcher\n}) => {\n  const onClickSwtach = useCallback(() => onToggleSketcher(index), [onToggleSketcher, index]);\n  const onColorInput = useCallback(v => inputColorHex(index, v), [inputColorHex, index]);\n  const onColorDelete = useCallback(() => onDelete(index), [onDelete, index]);\n  const onColorAdd = useCallback(() => onAdd(index), [onAdd, index]);\n  const showHexInput = !colorBreaks;\n\n  return (\n    <SortableItem id={`${index}`} isSorting={isSorting}>\n      {listeners => (\n        <>\n          <div className=\"custom-palette-input__left\">\n            <DragHandle className=\"layer__drag-handle\" {...listeners}>\n              <actionIcons.sort height=\"20px\" />\n            </DragHandle>\n            <ColorSwatch color={color} onClick={onClickSwtach} />\n            {showHexInput ? (\n              <StyledColorHexInput>\n                <ColorPaletteInput\n                  value={color.toUpperCase()}\n                  onChange={onColorInput}\n                  id={`input-layer-label-${index}`}\n                  editable\n                  textAlign=\"left\"\n                  width=\"70px\"\n                />\n              </StyledColorHexInput>\n            ) : null}\n            {colorBreaks && index < colorBreaks.length && isNumericColorBreaks(colorBreaks) ? (\n              <EditableColorRange\n                item={colorBreaks[index]}\n                isLast={index === colorBreaks.length - 1}\n                index={index}\n                editColorMap={editColorMapValue}\n                editable\n              />\n            ) : null}\n          </div>\n          <div className=\"custom-palette-input__right\">\n            {!disableAppend ? (\n              <AddColorStop onColorAdd={onColorAdd} IconComponent={actionIcons.add} />\n            ) : null}\n            {!disableDelete ? (\n              <DeleteColorStop onColorDelete={onColorDelete} IconComponent={actionIcons.delete} />\n            ) : null}\n          </div>\n        </>\n      )}\n    </SortableItem>\n  );\n};\n\nconst StyledCategoricalValuePickerWrapper = styled.div.attrs({\n  className: 'categorical-value-picker'\n})`\n  width: 150px;\n  color: ${props => props.theme.inputColor};\n  display: flex;\n  flex-direction: row;\n  justify-content: flex-end;\n  column-gap: 8px;\n  align-items: center;\n  cursor: pointer;\n`;\n\ntype StyledCategoricalValuePickerProps = {noBorder: boolean};\nconst StyledCategoricalValuePicker = styled.div<StyledCategoricalValuePickerProps>`\n  width: fit-content;\n  font-size: 11px;\n  border-bottom: ${props => (props.noBorder ? '' : '1px dashed')};\n  cursor: pointer;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow: hidden;\n  max-width: 100px;\n`;\n\ntype DropdownValuesWrapperProps = {width: number};\nconst DropdownValuesWrapper = styled.div<DropdownValuesWrapperProps>`\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ${props => props.theme.dropdownWrapperZ};\n  width: ${props => props.width}px;\n`;\n\ntype SelectedValuesWrapperProps = {width: number; height: number};\nconst SelectedValuesWrapper = styled(DropdownValuesWrapper)<SelectedValuesWrapperProps>`\n  width: ${props => props.width}px;\n  max-height: ${props => props.height}px;\n  overflow: auto;\n\n  .custom-palette-chickleted-input {\n    padding: 8px;\n    background-color: ${props => props.theme.dropdownWrapperZ};\n  }\n`;\n\nconst StyledDropdownHeader = styled.div`\n  display: flex;\n  flex-direction: row;\n  justify-content: space-between;\n  color: ${props => props.theme.inputColor};\n  padding: 0 8px;\n  font-size: 10px;\n\n  .button {\n    margin: 0;\n    padding: 0;\n    width: fit-content;\n  }\n`;\n\nconst StyledTooltipContent = styled.div`\n  padding: 8px;\n  width: 150px;\n  box-sizing: border-box;\n  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);\n\n  div {\n    overflow: hidden;\n    white-space: nowrap;\n    text-overflow: ellipsis;\n  }\n`;\n\nconst NUMBER_VALUES_IN_TOOLTIP = 10;\n\nconst CategoricalSelectorContext = React.createContext({\n  onSelectRest: () => null,\n  onReset: () => null\n});\n\n// Categorical values dropdownlist:\n// extending DropdownList and adding 'Select the Rest' and 'Reset' buttons\nclass ModifiedDropdownList extends DropdownList {\n  constructor(props) {\n    super(props);\n  }\n\n  render() {\n    return (\n      <>\n        <CategoricalSelectorContext.Consumer>\n          {context => (\n            <>\n              <StyledDropdownHeader>\n                <Button link size=\"smal\" onClick={context.onSelectRest}>\n                  Select the Rest\n                </Button>\n                <Button link size=\"smal\" onClick={context.onReset}>\n                  Reset\n                </Button>\n              </StyledDropdownHeader>\n              <DividerLine />\n              <DropdownList {...this.props} />\n            </>\n          )}\n        </CategoricalSelectorContext.Consumer>\n      </>\n    );\n  }\n}\n\nexport type CategoricalSelectorProps = {\n  index: number;\n  selectedValues: (string | number | null)[];\n  allValues: string[] | number[];\n  addColorMapValue?: (v: (number | string | null)[], i: number) => void;\n  removeColorMapValue?: (v: number | string, i: number) => void;\n  resetColorMapValue?: (i: number) => void;\n  selectRestColorMapValue?: (i: number) => void;\n  editable?: boolean;\n};\n\n// Categorical values selector for editing categorical values\nexport const CategoricalSelector: React.FC<CategoricalSelectorProps> = ({\n  index,\n  selectedValues,\n  allValues,\n  addColorMapValue,\n  removeColorMapValue,\n  resetColorMapValue,\n  selectRestColorMapValue,\n  editable = true\n}: CategoricalSelectorProps) => {\n  const [showTypeahead, setShowTypeahead] = useState(false);\n\n  const onOptionSelected = useCallback(\n    value => {\n      const previousSelected = toArray(selectedValues);\n      const items = uniq(previousSelected.concat(toArray(value)));\n      addColorMapValue?.(items, index);\n    },\n    [selectedValues, index, addColorMapValue]\n  );\n\n  const onOpenDropdown = useCallback(() => {\n    setShowTypeahead(true);\n  }, []);\n\n  const onCloseDropdown = useCallback(() => {\n    setShowTypeahead(false);\n  }, []);\n\n  const onRemoveItem = useCallback(\n    value => {\n      removeColorMapValue?.(value, index);\n    },\n    [index, removeColorMapValue]\n  );\n\n  const onReset = useCallback(() => {\n    resetColorMapValue?.(index);\n    setShowTypeahead(false);\n    return null;\n  }, [resetColorMapValue, index]);\n\n  const onSelectRest = useCallback(() => {\n    selectRestColorMapValue?.(index);\n    setShowTypeahead(false);\n    return null;\n  }, [selectRestColorMapValue, index]);\n\n  return (\n    <StyledCategoricalValuePickerWrapper>\n      {editable && <Add height=\"12px\" onClick={onOpenDropdown} />}\n      <StyledCategoricalValuePicker\n        noBorder={selectedValues.length === 0 || !editable}\n        onClick={onOpenDropdown}\n        data-tip\n        data-for={`category-values-${index}`}\n      >\n        {selectedValues.length === 0\n          ? 'Add Value'\n          : selectedValues.length === 1\n          ? selectedValues[0]\n          : `${selectedValues.length} selected`}\n        {selectedValues.length > 1 && (\n          <Tooltip id={`category-values-${index}`} place=\"top\" interactive={true}>\n            <StyledTooltipContent>\n              {selectedValues.slice(0, NUMBER_VALUES_IN_TOOLTIP).map((value, i) => (\n                <div key={i}>{value}</div>\n              ))}\n              {selectedValues.length > NUMBER_VALUES_IN_TOOLTIP && <div>...</div>}\n            </StyledTooltipContent>\n          </Tooltip>\n        )}\n      </StyledCategoricalValuePicker>\n      {editable && (\n        <Portaled left={0} top={0} isOpened={showTypeahead} onClose={onCloseDropdown}>\n          {selectedValues.length > 1 && (\n            <SelectedValuesWrapper width={250} height={200}>\n              <ChickletedInput\n                className={'custom-palette-chickleted-input'}\n                selectedItems={selectedValues}\n                placeholder={''}\n                removeItem={onRemoveItem}\n                onClick={() => null}\n                CustomChickletComponent={null}\n              />\n            </SelectedValuesWrapper>\n          )}\n          <DropdownValuesWrapper width={250}>\n            <div style={{position: 'relative'}}>\n              <CategoricalSelectorContext.Provider\n                value={{\n                  onReset,\n                  onSelectRest\n                }}\n              >\n                <Typeahead\n                  customClasses={{\n                    results: 'list-selector',\n                    input: 'typeahead__input',\n                    listItem: 'list__item',\n                    listAnchor: 'list__item__anchor'\n                  }}\n                  options={allValues}\n                  // add safe string casting for the Typeahead, so fuzzy search never receives non-strings, preventing the toLowerCase crash\n                  displayOption={o => String(o ?? '')}\n                  filterOption={(input, o) => String(o ?? '').includes(String(input ?? ''))}\n                  placeholder={'Search'}\n                  onOptionSelected={onOptionSelected}\n                  customListComponent={ModifiedDropdownList}\n                  customListItemComponent={ListItem}\n                  searchable={true}\n                  showOptionsWhenEmpty\n                  selectedItems={selectedValues}\n                />\n              </CategoricalSelectorContext.Provider>\n            </div>\n          </DropdownValuesWrapper>\n        </Portaled>\n      )}\n    </StyledCategoricalValuePickerWrapper>\n  );\n};\n\nexport type CategoricalCustomPaletteInputProps = {\n  index: number;\n  isSorting: boolean;\n  color: HexColor;\n  colorMap?: ColorMap | null;\n  addColorMapValue: (v: (number | string | null)[], i: number) => void;\n  removeColorMapValue: (v: number | string, i: number) => void;\n  resetColorMapValue: (i: number) => void;\n  selectRestColorMapValue: (i: number) => void;\n  actionIcons?: ActionIcons;\n  onDelete: (index: number) => void;\n  onAdd: (index: number) => void;\n  onToggleSketcher: (index: number) => void;\n  allValues: string[] | number[];\n  disableDelete?: boolean;\n};\n\nexport const CategoricalCustomPaletteInput: React.FC<CategoricalCustomPaletteInputProps> = ({\n  index,\n  isSorting,\n  color,\n  colorMap,\n  actionIcons = defaultActionIcons,\n  onDelete,\n  disableDelete,\n  onToggleSketcher,\n  addColorMapValue,\n  removeColorMapValue,\n  resetColorMapValue,\n  selectRestColorMapValue,\n  allValues\n}: CategoricalCustomPaletteInputProps) => {\n  const selectedValues: (number | string | null)[] = useMemo(() => {\n    if (!colorMap || !colorMap[index]) return [];\n    const value = colorMap[index][0];\n    const values = Array.isArray(value) ? value : value !== null ? [value] : [];\n    return values;\n  }, [colorMap, index]);\n\n  const onClickSwtach = useCallback(() => onToggleSketcher(index), [onToggleSketcher, index]);\n  const onColorDelete = useCallback(() => onDelete(index), [onDelete, index]);\n\n  return (\n    <SortableItem id={`${index}`} isSorting={isSorting}>\n      {listeners => (\n        <>\n          <div className=\"custom-palette-input__left\">\n            <DragHandle className=\"layer__drag-handle\" {...listeners}>\n              <actionIcons.sort height=\"20px\" />\n            </DragHandle>\n            <ColorSwatch color={color} onClick={onClickSwtach} />\n            {colorMap && colorMap[index] && (\n              <CategoricalSelector\n                selectedValues={selectedValues}\n                allValues={allValues}\n                addColorMapValue={addColorMapValue}\n                removeColorMapValue={removeColorMapValue}\n                resetColorMapValue={resetColorMapValue}\n                selectRestColorMapValue={selectRestColorMapValue}\n                index={index}\n              />\n            )}\n          </div>\n          <div className=\"custom-palette-input__right\">\n            {!disableDelete ? (\n              <DeleteColorStop onColorDelete={onColorDelete} IconComponent={actionIcons.delete} />\n            ) : null}\n          </div>\n        </>\n      )}\n    </SortableItem>\n  );\n};\n\nexport const BottomAction = ({onCancel, onConfirm}) => (\n  <StyledButtonContainer>\n    <Button className=\"confirm-apply__button\" small onClick={onConfirm}>\n      Confirm\n    </Button>\n    <Button link small onClick={onCancel}>\n      Cancel\n    </Button>\n  </StyledButtonContainer>\n);\n\nconst StyledCustomPalette = styled.div.attrs({\n  className: 'custom-palette'\n})`\n  margin-top: 8px;\n`;\n\nfunction CustomPaletteFactory(): React.FC<CustomPaletteProps> {\n  const CustomPalette: React.FC<CustomPaletteProps> = ({\n    ordinalDomain,\n    customPalette,\n    setColorPaletteUI,\n    showSketcher,\n    actionIcons = defaultActionIcons,\n    onCancel,\n    onApply\n  }) => {\n    const [isSorting, setIsSorting] = useState(false);\n    const {colors, colorMap} = customPalette;\n    const colorBreaks = useMemo(\n      () =>\n        colorMap\n          ? customPalette.type === 'custom'\n            ? colorMapToColorBreaks(colorMap)\n            : colorMapToCategoricalColorBreaks(colorMap)\n          : null,\n      [customPalette.type, colorMap]\n    );\n\n    const onPickerUpdate = useCallback(\n      color => {\n        if (color && Number.isFinite(showSketcher)) {\n          const newCustomPalette = updateCustomPaletteColor(\n            customPalette,\n            Number(showSketcher),\n            color.hex\n          );\n          setColorPaletteUI({\n            customPalette: newCustomPalette\n          });\n        }\n      },\n      [customPalette, showSketcher, setColorPaletteUI]\n    );\n    const onToggleSketcher = useCallback(\n      val => {\n        setColorPaletteUI({\n          showSketcher: val\n        });\n      },\n      [setColorPaletteUI]\n    );\n    const onDelete = useCallback(\n      index => {\n        const newCustomPalette = removeCustomPaletteColor(customPalette, index);\n        setColorPaletteUI({\n          customPalette: newCustomPalette\n        });\n      },\n      [customPalette, setColorPaletteUI]\n    );\n\n    const onAdd = useCallback(\n      index => {\n        // add color at the end\n        const newCustomPalette = addCustomPaletteColor(customPalette, index);\n        setColorPaletteUI({\n          customPalette: newCustomPalette\n        });\n      },\n      [customPalette, setColorPaletteUI]\n    );\n\n    const onAddCategoricalStep = useCallback(() => {\n      onAdd(colors.length - 1);\n    }, [colors.length, onAdd]);\n\n    const onSwatchClose = useCallback(() => {\n      onToggleSketcher(false);\n    }, [onToggleSketcher]);\n\n    const onConfirm = useCallback(\n      event => {\n        event.stopPropagation();\n        event.preventDefault();\n        onCancel();\n        onApply(event);\n      },\n      [onCancel, onApply]\n    );\n\n    const onSortEnd = useCallback(\n      (event: DragEndEvent) => {\n        const {active, over} = event;\n        if (over && active.id !== over.id) {\n          const oldIndex = colors.findIndex((_, index) => `${index}` === active.id);\n          const newIndex = colors.findIndex((_, index) => `${index}` === over.id);\n          const newCustomPalette = sortCustomPaletteColor(customPalette, oldIndex, newIndex);\n          setColorPaletteUI({\n            customPalette: newCustomPalette\n          });\n        }\n        setIsSorting(false);\n      },\n      [colors, customPalette, setIsSorting, setColorPaletteUI]\n    );\n\n    const onSortStart = useCallback(() => {\n      setIsSorting(true);\n    }, [setIsSorting]);\n\n    const inputColorHex = useCallback(\n      (index, value) => {\n        const newCustomPalette = updateCustomPaletteColor(customPalette, index, value);\n        // setColors(newColors);\n        setColorPaletteUI({\n          customPalette: newCustomPalette\n        });\n      },\n      [customPalette, setColorPaletteUI]\n    );\n\n    const editColorMapValue = useCallback(\n      (value, index) => {\n        if (!customPalette.colorMap) {\n          return;\n        }\n        const newColorMap = customPalette.colorMap.map(\n          (cm, i) => (i === index ? [value, cm[1]] : cm) as [string, string]\n        );\n\n        // sort the user inputs in case the break values are not ordered\n        const breaks = newColorMap\n          .map(cm => cm[0] as string | null)\n          .slice(0, -1)\n          .sort((a, b) => Number(a) - Number(b))\n          .concat(null);\n        const sortedNewColorMap: ColorMap = newColorMap.map((cm, i) => [breaks[i], cm[1]]);\n\n        setColorPaletteUI({\n          customPalette: {\n            ...customPalette,\n            colorMap: sortedNewColorMap\n          }\n        });\n      },\n      [setColorPaletteUI, customPalette]\n    );\n\n    // remove a selected category item from a color map\n    const removeCategoricalColorMapValue = useCallback(\n      (item, index) => {\n        if (!colorMap) {\n          return;\n        }\n        setColorPaletteUI({\n          customPalette: {\n            ...customPalette,\n            colorMap: removeCategoricalValueFromColorMap(colorMap, item, index)\n          }\n        });\n      },\n      [setColorPaletteUI, customPalette, colorMap]\n    );\n\n    // add selected categorical items to a color map\n    const addCategoricalColorMapValue = useCallback(\n      (items, index) => {\n        if (!colorMap) {\n          return;\n        }\n        setColorPaletteUI({\n          customPalette: {\n            ...customPalette,\n            colorMap: addCategoricalValuesToColorMap(colorMap, items, index)\n          }\n        });\n      },\n      [setColorPaletteUI, customPalette, colorMap]\n    );\n\n    // reset a color map\n    const resetCategoricalColorMapValue = useCallback(\n      index => {\n        if (!colorMap) {\n          return;\n        }\n        setColorPaletteUI({\n          customPalette: {\n            ...customPalette,\n            colorMap: resetCategoricalColorMapByIndex(colorMap, index)\n          }\n        });\n      },\n      [setColorPaletteUI, customPalette, colorMap]\n    );\n\n    // select the rest values for a color map\n    const selectRestCategoricalColorMap = useCallback(\n      index => {\n        if (!colorMap) {\n          return;\n        }\n        setColorPaletteUI({\n          customPalette: {\n            ...customPalette,\n            colorMap: selectRestCategoricalColorMapByIndex(colorMap, index, ordinalDomain)\n          }\n        });\n      },\n      [setColorPaletteUI, customPalette, colorMap, ordinalDomain]\n    );\n\n    return (\n      <StyledCustomPalette>\n        <WrappedSortableContainer\n          className=\"custom-palette__sortable-container\"\n          onSortEnd={onSortEnd}\n          onSortStart={onSortStart}\n        >\n          {colors.map((color, index) =>\n            customPalette.type === 'custom' ? (\n              <CustomPaletteInput\n                key={index}\n                colorBreaks={colorBreaks}\n                index={index}\n                isSorting={isSorting}\n                color={color}\n                inputColorHex={inputColorHex}\n                disableAppend={colors.length >= 20}\n                disableDelete={colors.length <= 2}\n                actionIcons={actionIcons}\n                onAdd={onAdd}\n                onDelete={onDelete}\n                onToggleSketcher={onToggleSketcher}\n                editColorMapValue={editColorMapValue}\n              />\n            ) : (\n              ordinalDomain && (\n                <CategoricalCustomPaletteInput\n                  key={index}\n                  colorMap={colorMap}\n                  index={index}\n                  isSorting={isSorting}\n                  color={color}\n                  actionIcons={actionIcons}\n                  onAdd={onAdd}\n                  onDelete={onDelete}\n                  disableDelete={colors.length <= 2}\n                  onToggleSketcher={onToggleSketcher}\n                  addColorMapValue={addCategoricalColorMapValue}\n                  removeColorMapValue={removeCategoricalColorMapValue}\n                  resetColorMapValue={resetCategoricalColorMapValue}\n                  selectRestColorMapValue={selectRestCategoricalColorMap}\n                  allValues={ordinalDomain}\n                />\n              )\n            )\n          )}\n        </WrappedSortableContainer>\n        {customPalette.type === 'customOrdinal' && (\n          <StyledAddStepContainer>\n            <AddColorStop onColorAdd={onAddCategoricalStep} IconComponent={actionIcons.add} />\n            <Button link size=\"smal\" onClick={onAddCategoricalStep}>\n              Add Step\n            </Button>\n          </StyledAddStepContainer>\n        )}\n        <DividerLine />\n        {/* Cancel or Confirm Buttons */}\n        <BottomAction onCancel={onCancel} onConfirm={onConfirm} />\n        <Portaled isOpened={showSketcher !== false} left={280} top={-300} onClose={onSwatchClose}>\n          <CustomPicker color={colors[Number(showSketcher)]} onChange={onPickerUpdate} />\n        </Portaled>\n      </StyledCustomPalette>\n    );\n  };\n\n  return CustomPalette;\n}\n\nexport default CustomPaletteFactory;\n"],"mappings":"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","ignoreList":[]}