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

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

@@ -0,0 +1,288 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _excluded = ["layer", "field", "dataset", "onSelect", "scaleType", "domain", "aggregatedBins", "range", "setColorUI", "colorUIConfig", "channelKey"],
+  _excluded2 = ["colorMap"];
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo, useState } from 'react';
+import styled from 'styled-components';
+import { ALL_FIELD_TYPES, SCALE_TYPES } from '@kepler.gl/constants';
+import { getLayerColorScale, getLegendOfScale, initCustomPaletteByCustomScale, histogramFromValues, histogramFromOrdinal, histogramFromThreshold, getHistogramDomain, hasColorMap } from '@kepler.gl/utils';
+import ColorBreaksPanelFactory from './color-breaks-panel';
+import DropdownSelect from '../../common/item-selector/dropdown-select';
+import Accessor from '../../common/item-selector/accessor';
+import DropdownList from '../../common/item-selector/dropdown-list';
+import LazyTippy from '../../map/lazy-tippy';
+import Typeahead from '../../common/item-selector/typeahead';
+// 'tippy-js'
+
+var HISTOGRAM_BINS = 30;
+var DropdownPropContext = /*#__PURE__*/React.createContext({});
+var POPPER_OPTIONS = {
+  modifiers: [
+  // zero offsets since they are already added in VerticalToolbar
+  {
+    name: 'offset',
+    options: {
+      offset: [0, 0]
+    }
+  }]
+};
+var DropdownBottom = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  border-top: 1px solid\n    ", ";\n"])), function (props) {
+  return props.light ? props.theme.dropdownListBorderTopLT : props.theme.dropdownListBorderTop;
+});
+var StyledScaleSelectDropdown = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  box-shadow: ", ";\n  .list-selector {\n    box-shadow: none;\n    border-top: 0;\n  }\n  .list__item {\n    padding: 4px 9px;\n  }\n"])), function (props) {
+  return props.theme.dropdownListShadow;
+});
+var DropdownWrapper = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ", ";\n  position: absolute;\n  margin-top: ", "px;\n"])), function (props) {
+  return props.theme.dropdownWrapperZ;
+}, function (props) {
+  return props.theme.dropdownWapperMargin;
+});
+var StyledColorScaleSelector = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  position: relative;\n  .typeahead {\n    // adds padding to bottom of dropdown\n    margin-bottom: 40px;\n  }\n  [data-tippy-root] {\n    width: 100%;\n  }\n"])));
+function hideTippy(tippyInstance) {
+  if (tippyInstance) {
+    tippyInstance.hide();
+  }
+}
+ColorScaleSelectorFactory.deps = [ColorBreaksPanelFactory];
+function ColorScaleSelectorFactory(ColorBreaksPanel) {
+  var ColorScaleSelectDropdown = function ColorScaleSelectDropdown(props) {
+    return /*#__PURE__*/React.createElement(StyledScaleSelectDropdown, null, /*#__PURE__*/React.createElement(DropdownList, props), /*#__PURE__*/React.createElement(DropdownPropContext.Consumer, null, function (context) {
+      return /*#__PURE__*/React.createElement(DropdownBottom, null, /*#__PURE__*/React.createElement(ColorBreaksPanel, context));
+    }));
+  };
+  var ColorScaleSelector = function ColorScaleSelector(_ref) {
+    var _colorUIConfig$colorR, _colorUIConfig$custom2, _field$filterProps;
+    var layer = _ref.layer,
+      field = _ref.field,
+      dataset = _ref.dataset,
+      onSelect = _ref.onSelect,
+      scaleType = _ref.scaleType,
+      domain = _ref.domain,
+      aggregatedBins = _ref.aggregatedBins,
+      range = _ref.range,
+      setColorUI = _ref.setColorUI,
+      colorUIConfig = _ref.colorUIConfig,
+      channelKey = _ref.channelKey,
+      dropdownSelectProps = _objectWithoutProperties(_ref, _excluded);
+    var displayOption = Accessor.generateOptionToStringFor(dropdownSelectProps.displayOption);
+    var getOptionValue = useMemo(function () {
+      return Accessor.generateOptionToStringFor(dropdownSelectProps.getOptionValue);
+    }, [dropdownSelectProps.getOptionValue]);
+    var _useState = useState(),
+      _useState2 = _slicedToArray(_useState, 2),
+      tippyInstance = _useState2[0],
+      setTippyInstance = _useState2[1];
+    var isEditingColorBreaks = colorUIConfig === null || colorUIConfig === void 0 || (_colorUIConfig$colorR = colorUIConfig.colorRangeConfig) === null || _colorUIConfig$colorR === void 0 ? void 0 : _colorUIConfig$colorR.customBreaks;
+
+    // Stores the previous selection for live preview: when choosing Custom/Custom Ordinal, we apply a temporary palette.
+    // Cancel restores {scale, range} from this ref; Confirm keeps the change and clears the ref.
+    // If the user switches between different custom scale types (e.g., from "Custom" to "Custom Ordinal") or is already in a custom scale state,
+    // this ref is updated to always store the most recent non-custom selection. Only the latest non-custom selection is restorable on cancel.
+    var prevSelectionRef = React.useRef(null);
+
+    // when custom color scale - but Confirm is not clicked yet
+    var pendingOption = useMemo(function () {
+      return isEditingColorBreaks ? (dropdownSelectProps.options || []).find(function (o) {
+        var _colorUIConfig$custom;
+        return getOptionValue(o) === (colorUIConfig === null || colorUIConfig === void 0 || (_colorUIConfig$custom = colorUIConfig.customPalette) === null || _colorUIConfig$custom === void 0 ? void 0 : _colorUIConfig$custom.type);
+      }) || null : null;
+    }, [isEditingColorBreaks, dropdownSelectProps.options, getOptionValue, colorUIConfig === null || colorUIConfig === void 0 || (_colorUIConfig$custom2 = colorUIConfig.customPalette) === null || _colorUIConfig$custom2 === void 0 ? void 0 : _colorUIConfig$custom2.type]);
+    var colorScale = useMemo(function () {
+      return getLayerColorScale({
+        range: range,
+        domain: domain,
+        scaleType: scaleType,
+        layer: layer
+      });
+    }, [range, domain, scaleType, layer]);
+    var colorBreaks = useMemo(function () {
+      var _field$type;
+      return colorScale ? getLegendOfScale({
+        scale: colorScale.byZoom && domain ? colorScale((domain === null || domain === void 0 ? void 0 : domain.length) - 1) : colorScale,
+        scaleType: scaleType,
+        fieldType: (_field$type = field === null || field === void 0 ? void 0 : field.type) !== null && _field$type !== void 0 ? _field$type : ALL_FIELD_TYPES.real
+      }) : null;
+    }, [colorScale, scaleType, field === null || field === void 0 ? void 0 : field.type, domain]);
+    var columnStats = field === null || field === void 0 || (_field$filterProps = field.filterProps) === null || _field$filterProps === void 0 ? void 0 : _field$filterProps.columnStats;
+    var fieldValueAccessor = useMemo(function () {
+      return field ? function (idx) {
+        return dataset.getValue(field.name, idx);
+      } : function (idx) {
+        return dataset.dataContainer.rowAsArray(idx);
+      };
+    }, [dataset, field]);
+    var ordinalDomain = useMemo(function () {
+      return layer.config[layer.visualChannels[channelKey].domain] || [];
+    }, [channelKey, layer.config, layer.visualChannels]);
+
+    // aggregatedBins should be the raw data
+    var allBins = useMemo(function () {
+      if ((field === null || field === void 0 ? void 0 : field.type) === ALL_FIELD_TYPES.string) {
+        // Use ordinal bins for string columns, as d3 could potentially generate invalid numeric bins, and crash
+        return histogramFromOrdinal(ordinalDomain, dataset.allIndexes, fieldValueAccessor);
+      }
+      if (aggregatedBins) {
+        return histogramFromValues(Object.values(aggregatedBins).map(function (bin) {
+          return bin.i;
+        }), HISTOGRAM_BINS, function (idx) {
+          return aggregatedBins[idx].value;
+        });
+      }
+      return columnStats !== null && columnStats !== void 0 && columnStats.bins ? columnStats === null || columnStats === void 0 ? void 0 : columnStats.bins : histogramFromValues(dataset.allIndexes, HISTOGRAM_BINS, fieldValueAccessor);
+    }, [aggregatedBins, columnStats, dataset, fieldValueAccessor, field === null || field === void 0 ? void 0 : field.type, ordinalDomain]);
+    var histogramDomain = useMemo(function () {
+      return getHistogramDomain({
+        aggregatedBins: aggregatedBins,
+        columnStats: columnStats,
+        dataset: dataset,
+        fieldValueAccessor: fieldValueAccessor
+      });
+    }, [dataset, fieldValueAccessor, aggregatedBins, columnStats]);
+    var isFiltered = aggregatedBins ? false : dataset.filteredIndexForDomain.length !== dataset.allIndexes.length;
+
+    // get filteredBins (not apply to aggregate layer)
+    var filteredBins = useMemo(function () {
+      if (!isFiltered) {
+        return allBins;
+      }
+      if ((field === null || field === void 0 ? void 0 : field.type) === ALL_FIELD_TYPES.string) {
+        return histogramFromOrdinal(ordinalDomain, dataset.filteredIndexForDomain, fieldValueAccessor);
+      }
+      // numeric thresholds
+      var filterEmptyBins = false;
+      var thresholds = allBins.map(function (b) {
+        return b.x0;
+      });
+      return histogramFromThreshold(thresholds, dataset.filteredIndexForDomain, fieldValueAccessor, filterEmptyBins);
+    }, [dataset, fieldValueAccessor, allBins, isFiltered, field === null || field === void 0 ? void 0 : field.type, ordinalDomain]);
+    var onSelectScale = useCallback(function (val) {
+      // highlight selected option
+      if (!val) return;
+      var selectedScale = getOptionValue(val);
+      if (selectedScale === SCALE_TYPES.custom || selectedScale === SCALE_TYPES.customOrdinal) {
+        var customPalette = initCustomPaletteByCustomScale(_objectSpread({
+          scale: selectedScale,
+          field: field,
+          range: range,
+          colorBreaks: colorBreaks
+        }, selectedScale === SCALE_TYPES.customOrdinal ? {
+          ordinalDomain: ordinalDomain
+        } : {}));
+        setColorUI({
+          showColorChart: true,
+          colorRangeConfig: {
+            customBreaks: true
+          },
+          customPalette: customPalette
+        });
+        // store previous selection for cancel, then preview custom on the map
+        if (!prevSelectionRef.current) {
+          prevSelectionRef.current = {
+            scale: scaleType,
+            range: range
+          };
+        }
+        onSelect(selectedScale, customPalette);
+      } else if (hasColorMap(range)) {
+        // not custom
+        // remove colorMap
+        // eslint-disable-next-line no-unused-vars
+        var _ = range.colorMap,
+          newRange = _objectWithoutProperties(range, _excluded2);
+        // reset colorUI before changing the scale
+        setColorUI({
+          showColorChart: false,
+          colorRangeConfig: {
+            customBreaks: false
+          }
+        });
+        onSelect(selectedScale, newRange);
+      } else {
+        // reset colorUI before changing the scale
+        setColorUI({
+          showColorChart: false,
+          colorRangeConfig: {
+            customBreaks: false
+          }
+        });
+        onSelect(selectedScale);
+      }
+    }, [field, setColorUI, onSelect, range, getOptionValue, colorBreaks, ordinalDomain, scaleType]);
+    var onApply = useCallback(function () {
+      var _colorUIConfig$custom3;
+      // change scale type only if confirmed
+      var nextScaleType = (colorUIConfig === null || colorUIConfig === void 0 || (_colorUIConfig$custom3 = colorUIConfig.customPalette) === null || _colorUIConfig$custom3 === void 0 ? void 0 : _colorUIConfig$custom3.type) || scaleType;
+      onSelect(nextScaleType, colorUIConfig.customPalette);
+      hideTippy(tippyInstance);
+      prevSelectionRef.current = null;
+    }, [onSelect, colorUIConfig.customPalette, tippyInstance, scaleType]);
+    var onCancel = useCallback(function () {
+      // restore previous selection if any
+      if (prevSelectionRef.current) {
+        var _prevSelectionRef$cur = prevSelectionRef.current,
+          prevScale = _prevSelectionRef$cur.scale,
+          prevRange = _prevSelectionRef$cur.range;
+        onSelect(prevScale, prevRange);
+      }
+      hideTippy(tippyInstance);
+      prevSelectionRef.current = null;
+    }, [tippyInstance, onSelect]);
+    var isCustomBreaks = scaleType === SCALE_TYPES.custom || scaleType === SCALE_TYPES.customOrdinal;
+    return /*#__PURE__*/React.createElement(DropdownPropContext.Provider, {
+      value: {
+        setColorUI: setColorUI,
+        colorField: field,
+        dataset: dataset,
+        colorUIConfig: colorUIConfig,
+        colorBreaks: colorBreaks,
+        isCustomBreaks: isCustomBreaks,
+        allBins: allBins,
+        filteredBins: filteredBins,
+        isFiltered: isFiltered,
+        histogramDomain: histogramDomain,
+        ordinalDomain: ordinalDomain,
+        onScaleChange: onSelect,
+        onApply: onApply,
+        onCancel: onCancel
+      }
+    }, /*#__PURE__*/React.createElement(StyledColorScaleSelector, null, /*#__PURE__*/React.createElement(LazyTippy, {
+      trigger: "click",
+      placement: "bottom-start",
+      appendTo: "parent",
+      interactive: true,
+      hideOnClick: !isEditingColorBreaks,
+      onCreate: setTippyInstance,
+      popperOptions: POPPER_OPTIONS,
+      render: function render(attrs) {
+        return /*#__PURE__*/React.createElement(DropdownWrapper, attrs, !dropdownSelectProps.disabled && /*#__PURE__*/React.createElement(Typeahead, _extends({}, dropdownSelectProps, {
+          displayOption: displayOption
+          // @ts-ignore
+          ,
+          getOptionValue: getOptionValue,
+          onOptionSelected: onSelectScale,
+          customListComponent: ColorScaleSelectDropdown,
+          searchable: false,
+          showOptionsWhenEmpty: true,
+          selectedItems: pendingOption ? [pendingOption] : dropdownSelectProps.selectedItems
+        })));
+      }
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "dropdown-select"
+    }, /*#__PURE__*/React.createElement(DropdownSelect, _extends({}, dropdownSelectProps, {
+      displayOption: displayOption,
+      value: pendingOption || dropdownSelectProps.selectedItems[0]
+    }))))));
+  };
+  return ColorScaleSelector;
+}
+export default ColorScaleSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","useState","styled","ALL_FIELD_TYPES","SCALE_TYPES","getLayerColorScale","getLegendOfScale","initCustomPaletteByCustomScale","histogramFromValues","histogramFromOrdinal","histogramFromThreshold","getHistogramDomain","hasColorMap","ColorBreaksPanelFactory","DropdownSelect","Accessor","DropdownList","LazyTippy","Typeahead","HISTOGRAM_BINS","DropdownPropContext","createContext","POPPER_OPTIONS","modifiers","name","options","offset","DropdownBottom","div","_templateObject","_taggedTemplateLiteral","props","light","theme","dropdownListBorderTopLT","dropdownListBorderTop","StyledScaleSelectDropdown","_templateObject2","dropdownListShadow","DropdownWrapper","_templateObject3","dropdownWrapperZ","dropdownWapperMargin","StyledColorScaleSelector","_templateObject4","hideTippy","tippyInstance","hide","ColorScaleSelectorFactory","deps","ColorBreaksPanel","ColorScaleSelectDropdown","createElement","Consumer","context","ColorScaleSelector","_ref","_colorUIConfig$colorR","_colorUIConfig$custom2","_field$filterProps","layer","field","dataset","onSelect","scaleType","domain","aggregatedBins","range","setColorUI","colorUIConfig","channelKey","dropdownSelectProps","_objectWithoutProperties","_excluded","displayOption","generateOptionToStringFor","getOptionValue","_useState","_useState2","_slicedToArray","setTippyInstance","isEditingColorBreaks","colorRangeConfig","customBreaks","prevSelectionRef","useRef","pendingOption","find","o","_colorUIConfig$custom","customPalette","type","colorScale","colorBreaks","_field$type","scale","byZoom","length","fieldType","real","columnStats","filterProps","fieldValueAccessor","idx","getValue","dataContainer","rowAsArray","ordinalDomain","config","visualChannels","allBins","string","allIndexes","Object","values","map","bin","i","value","bins","histogramDomain","isFiltered","filteredIndexForDomain","filteredBins","filterEmptyBins","thresholds","b","x0","onSelectScale","val","selectedScale","custom","customOrdinal","_objectSpread","showColorChart","current","_","colorMap","newRange","_excluded2","onApply","_colorUIConfig$custom3","nextScaleType","onCancel","_prevSelectionRef$cur","prevScale","prevRange","isCustomBreaks","Provider","colorField","onScaleChange","trigger","placement","appendTo","interactive","hideOnClick","onCreate","popperOptions","render","attrs","disabled","_extends","onOptionSelected","customListComponent","searchable","showOptionsWhenEmpty","selectedItems","className"],"sources":["../../../../src/side-panel/layer-panel/color-scale-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo, useState} from 'react';\nimport styled from 'styled-components';\n\nimport {ALL_FIELD_TYPES, SCALE_TYPES} from '@kepler.gl/constants';\nimport {AggregatedBin, Layer, VisualChannelDomain} from '@kepler.gl/layers';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {ColorRange, ColorUI, Field} from '@kepler.gl/types';\nimport {\n  getLayerColorScale,\n  getLegendOfScale,\n  initCustomPaletteByCustomScale,\n  histogramFromValues,\n  histogramFromOrdinal,\n  histogramFromThreshold,\n  getHistogramDomain,\n  hasColorMap\n} from '@kepler.gl/utils';\n\nimport ColorBreaksPanelFactory, {ColorBreaksPanelProps} from './color-breaks-panel';\nimport {SetColorUIFunc} from './custom-palette';\nimport DropdownSelect from '../../common/item-selector/dropdown-select';\nimport Accessor from '../../common/item-selector/accessor';\nimport DropdownList from '../../common/item-selector/dropdown-list';\nimport LazyTippy from '../../map/lazy-tippy';\nimport Typeahead from '../../common/item-selector/typeahead';\n\ntype TippyInstance = any; // 'tippy-js'\n\nconst HISTOGRAM_BINS = 30;\n\nexport type ScaleOption = {\n  label: string;\n  value: string;\n};\nexport type OnSelectFunc = (v: string, visConfg?: Record<string, any>) => void;\n\nexport type ContextProps = ColorBreaksPanelProps;\n\nexport type ColorScaleSelectorProps = {\n  layer: Layer;\n  field: Field;\n  dataset: KeplerTable;\n  scaleType: string;\n  domain: VisualChannelDomain;\n  range: ColorRange;\n  onSelect: OnSelectFunc;\n  setColorUI: SetColorUIFunc;\n  colorUIConfig: ColorUI;\n  options: ScaleOption[];\n  disabled?: boolean;\n  selectedItems: ScaleOption[];\n  multiSelect: boolean;\n  searchable: boolean;\n  displayOption: string;\n  getOptionValue: string;\n  aggregatedBins?: Record<number, AggregatedBin>;\n  channelKey: string;\n};\n\nconst DropdownPropContext = React.createContext({});\nconst POPPER_OPTIONS = {\n  modifiers: [\n    // zero offsets since they are already added in VerticalToolbar\n    {name: 'offset', options: {offset: [0, 0]}}\n  ]\n};\n\nconst DropdownBottom = styled.div<{light?: boolean}>`\n  border-top: 1px solid\n    ${props =>\n      props.light ? props.theme.dropdownListBorderTopLT : props.theme.dropdownListBorderTop};\n`;\n\nconst StyledScaleSelectDropdown = styled.div`\n  box-shadow: ${props => props.theme.dropdownListShadow};\n  .list-selector {\n    box-shadow: none;\n    border-top: 0;\n  }\n  .list__item {\n    padding: 4px 9px;\n  }\n`;\nconst DropdownWrapper = styled.div`\n  border: 0;\n  width: 100%;\n  left: 0;\n  z-index: ${props => props.theme.dropdownWrapperZ};\n  position: absolute;\n  margin-top: ${props => props.theme.dropdownWapperMargin}px;\n`;\n\nconst StyledColorScaleSelector = styled.div`\n  position: relative;\n  .typeahead {\n    // adds padding to bottom of dropdown\n    margin-bottom: 40px;\n  }\n  [data-tippy-root] {\n    width: 100%;\n  }\n`;\n\nfunction hideTippy(tippyInstance) {\n  if (tippyInstance) {\n    tippyInstance.hide();\n  }\n}\nColorScaleSelectorFactory.deps = [ColorBreaksPanelFactory];\n\nfunction ColorScaleSelectorFactory(\n  ColorBreaksPanel: ReturnType<typeof ColorBreaksPanelFactory>\n): React.FC<ColorScaleSelectorProps> {\n  const ColorScaleSelectDropdown = props => (\n    <StyledScaleSelectDropdown>\n      <DropdownList {...props} />\n      <DropdownPropContext.Consumer>\n        {(context: any) => (\n          <DropdownBottom>\n            <ColorBreaksPanel {...context} />\n          </DropdownBottom>\n        )}\n      </DropdownPropContext.Consumer>\n    </StyledScaleSelectDropdown>\n  );\n\n  const ColorScaleSelector: React.FC<ColorScaleSelectorProps> = ({\n    layer,\n    field,\n    dataset,\n    onSelect,\n    scaleType,\n    domain,\n    aggregatedBins,\n    range,\n    setColorUI,\n    colorUIConfig,\n    channelKey,\n    ...dropdownSelectProps\n  }) => {\n    const displayOption = Accessor.generateOptionToStringFor(dropdownSelectProps.displayOption);\n    const getOptionValue = useMemo(\n      () => Accessor.generateOptionToStringFor(dropdownSelectProps.getOptionValue),\n      [dropdownSelectProps.getOptionValue]\n    );\n    const [tippyInstance, setTippyInstance] = useState<TippyInstance>();\n    const isEditingColorBreaks = colorUIConfig?.colorRangeConfig?.customBreaks;\n\n    // Stores the previous selection for live preview: when choosing Custom/Custom Ordinal, we apply a temporary palette.\n    // Cancel restores {scale, range} from this ref; Confirm keeps the change and clears the ref.\n    // If the user switches between different custom scale types (e.g., from \"Custom\" to \"Custom Ordinal\") or is already in a custom scale state,\n    // this ref is updated to always store the most recent non-custom selection. Only the latest non-custom selection is restorable on cancel.\n    const prevSelectionRef = React.useRef<{scale: string; range: ColorRange} | null>(null);\n\n    // when custom color scale - but Confirm is not clicked yet\n    const pendingOption = useMemo(\n      () =>\n        isEditingColorBreaks\n          ? (dropdownSelectProps.options || []).find(\n              o => getOptionValue(o) === colorUIConfig?.customPalette?.type\n            ) || null\n          : null,\n      [\n        isEditingColorBreaks,\n        dropdownSelectProps.options,\n        getOptionValue,\n        colorUIConfig?.customPalette?.type\n      ]\n    );\n    const colorScale = useMemo(\n      () =>\n        getLayerColorScale({\n          range,\n          domain,\n          scaleType,\n          layer\n        }),\n      [range, domain, scaleType, layer]\n    );\n\n    const colorBreaks = useMemo(() => {\n      return colorScale\n        ? getLegendOfScale({\n            scale: colorScale.byZoom && domain ? colorScale(domain?.length - 1) : colorScale,\n            scaleType,\n            fieldType: field?.type ?? ALL_FIELD_TYPES.real\n          })\n        : null;\n    }, [colorScale, scaleType, field?.type, domain]);\n\n    const columnStats = field?.filterProps?.columnStats;\n\n    const fieldValueAccessor = useMemo(() => {\n      return field\n        ? idx => dataset.getValue(field.name, idx)\n        : idx => dataset.dataContainer.rowAsArray(idx);\n    }, [dataset, field]);\n\n    const ordinalDomain = useMemo(() => {\n      return layer.config[layer.visualChannels[channelKey].domain] || [];\n    }, [channelKey, layer.config, layer.visualChannels]);\n\n    // aggregatedBins should be the raw data\n    const allBins = useMemo(() => {\n      if (field?.type === ALL_FIELD_TYPES.string) {\n        // Use ordinal bins for string columns, as d3 could potentially generate invalid numeric bins, and crash\n        return histogramFromOrdinal(ordinalDomain, dataset.allIndexes, fieldValueAccessor);\n      }\n\n      if (aggregatedBins) {\n        return histogramFromValues(\n          Object.values(aggregatedBins).map(bin => bin.i),\n          HISTOGRAM_BINS,\n          idx => aggregatedBins[idx].value\n        );\n      }\n      return columnStats?.bins\n        ? columnStats?.bins\n        : histogramFromValues(dataset.allIndexes, HISTOGRAM_BINS, fieldValueAccessor);\n    }, [aggregatedBins, columnStats, dataset, fieldValueAccessor, field?.type, ordinalDomain]);\n\n    const histogramDomain = useMemo(() => {\n      return getHistogramDomain({aggregatedBins, columnStats, dataset, fieldValueAccessor});\n    }, [dataset, fieldValueAccessor, aggregatedBins, columnStats]);\n\n    const isFiltered = aggregatedBins\n      ? false\n      : dataset.filteredIndexForDomain.length !== dataset.allIndexes.length;\n\n    // get filteredBins (not apply to aggregate layer)\n    const filteredBins = useMemo(() => {\n      if (!isFiltered) {\n        return allBins;\n      }\n      if (field?.type === ALL_FIELD_TYPES.string) {\n        return histogramFromOrdinal(\n          ordinalDomain as any,\n          dataset.filteredIndexForDomain,\n          fieldValueAccessor\n        );\n      }\n      // numeric thresholds\n      const filterEmptyBins = false;\n      const thresholds = allBins.map(b => b.x0);\n      return histogramFromThreshold(\n        thresholds,\n        dataset.filteredIndexForDomain,\n        fieldValueAccessor,\n        filterEmptyBins\n      );\n    }, [dataset, fieldValueAccessor, allBins, isFiltered, field?.type, ordinalDomain]);\n\n    const onSelectScale = useCallback(\n      val => {\n        // highlight selected option\n        if (!val) return;\n\n        const selectedScale = getOptionValue(val);\n        if (selectedScale === SCALE_TYPES.custom || selectedScale === SCALE_TYPES.customOrdinal) {\n          const customPalette = initCustomPaletteByCustomScale({\n            scale: selectedScale,\n            field,\n            range,\n            colorBreaks,\n            ...(selectedScale === SCALE_TYPES.customOrdinal ? {ordinalDomain} : {})\n          });\n          setColorUI({\n            showColorChart: true,\n            colorRangeConfig: {\n              customBreaks: true\n            },\n            customPalette\n          });\n          // store previous selection for cancel, then preview custom on the map\n          if (!prevSelectionRef.current) {\n            prevSelectionRef.current = {scale: scaleType, range};\n          }\n          onSelect(selectedScale, customPalette);\n        } else if (hasColorMap(range)) {\n          // not custom\n          // remove colorMap\n          // eslint-disable-next-line no-unused-vars\n          const {colorMap: _, ...newRange} = range;\n          // reset colorUI before changing the scale\n          setColorUI({\n            showColorChart: false,\n            colorRangeConfig: {\n              customBreaks: false\n            }\n          });\n          onSelect(selectedScale, newRange);\n        } else {\n          // reset colorUI before changing the scale\n          setColorUI({\n            showColorChart: false,\n            colorRangeConfig: {\n              customBreaks: false\n            }\n          });\n          onSelect(selectedScale);\n        }\n      },\n      [field, setColorUI, onSelect, range, getOptionValue, colorBreaks, ordinalDomain, scaleType]\n    );\n\n    const onApply = useCallback(() => {\n      // change scale type only if confirmed\n      const nextScaleType = colorUIConfig?.customPalette?.type || scaleType;\n      onSelect(nextScaleType, colorUIConfig.customPalette);\n      hideTippy(tippyInstance);\n      prevSelectionRef.current = null;\n    }, [onSelect, colorUIConfig.customPalette, tippyInstance, scaleType]);\n\n    const onCancel = useCallback(() => {\n      // restore previous selection if any\n      if (prevSelectionRef.current) {\n        const {scale: prevScale, range: prevRange} = prevSelectionRef.current;\n        onSelect(prevScale, prevRange);\n      }\n      hideTippy(tippyInstance);\n      prevSelectionRef.current = null;\n    }, [tippyInstance, onSelect]);\n\n    const isCustomBreaks =\n      scaleType === SCALE_TYPES.custom || scaleType === SCALE_TYPES.customOrdinal;\n\n    return (\n      <DropdownPropContext.Provider\n        value={{\n          setColorUI,\n          colorField: field,\n          dataset,\n          colorUIConfig,\n          colorBreaks,\n          isCustomBreaks,\n          allBins,\n          filteredBins,\n          isFiltered,\n          histogramDomain,\n          ordinalDomain,\n          onScaleChange: onSelect,\n          onApply,\n          onCancel\n        }}\n      >\n        <StyledColorScaleSelector>\n          <LazyTippy\n            trigger=\"click\"\n            placement=\"bottom-start\"\n            appendTo=\"parent\"\n            interactive={true}\n            hideOnClick={!isEditingColorBreaks}\n            onCreate={setTippyInstance}\n            popperOptions={POPPER_OPTIONS}\n            render={attrs => (\n              <DropdownWrapper {...attrs}>\n                {/* @ts-ignore*/}\n                {!dropdownSelectProps.disabled && (\n                  <Typeahead\n                    {...dropdownSelectProps}\n                    displayOption={displayOption}\n                    // @ts-ignore\n                    getOptionValue={getOptionValue}\n                    onOptionSelected={onSelectScale}\n                    customListComponent={ColorScaleSelectDropdown}\n                    searchable={false}\n                    showOptionsWhenEmpty\n                    selectedItems={\n                      pendingOption ? [pendingOption] : dropdownSelectProps.selectedItems\n                    }\n                  />\n                )}\n              </DropdownWrapper>\n            )}\n          >\n            <div className=\"dropdown-select\">\n              {/* @ts-ignore*/}\n              <DropdownSelect\n                {...dropdownSelectProps}\n                displayOption={displayOption}\n                value={pendingOption || dropdownSelectProps.selectedItems[0]}\n              />\n            </div>\n          </LazyTippy>\n        </StyledColorScaleSelector>\n      </DropdownPropContext.Provider>\n    );\n  };\n  return ColorScaleSelector;\n}\nexport default ColorScaleSelectorFactory;\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,179 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+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, useState } from 'react';
+import { FormattedMessage } from 'react-intl';
+import styled from 'styled-components';
+import { useDismiss, useFloating, useInteractions } from '@floating-ui/react';
+import { rgbToHex } from '@kepler.gl/utils';
+import RangeSliderFactory from '../../common/range-slider';
+import { PanelLabel, shouldForwardProp, StyledPanelDropdown } from '../../common/styled-components';
+import ColorPalette from './color-palette';
+import ColorRangeSelectorFactory from './color-range-selector';
+import SingleColorPalette from './single-color-palette';
+var OpacitySliderWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  padding: 0px 12px 12px 12px;\n"])));
+var OPACITY_SLIDER_PROPS = {
+  type: 'number',
+  range: [0, 1],
+  value0: 0,
+  step: 0.01,
+  isRanged: false,
+  label: 'Opacity',
+  showInput: true
+};
+export var ColorBlock = styled.div.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  width: 32px;\n  height: 18px;\n  border-radius: 1px;\n  background-color: ", ";\n"])), function (props) {
+  return Array.isArray(props.backgroundcolor) ? "rgb(".concat(props.backgroundcolor.slice(0, 3).join(','), ")") : 'transparent';
+});
+var StyledColorSelectorWrapper = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  .selector__dropdown {\n    max-height: 600px; /* increase from the default 500px defined by StyledPanelDropdown */\n  }\n"])));
+export var ColorSelectorInput = styled.div.withConfig({
+  shouldForwardProp: shouldForwardProp
+})(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  ", ";\n  height: ", ";\n\n  .color-selector__selector__label {\n    text-transform: capitalize;\n    font-size: 12px;\n    text-align: center;\n    color: ", ";\n  }\n"])), function (props) {
+  return props.inputTheme === 'secondary' ? props.theme.secondaryInput : props.theme.input;
+}, function (props) {
+  return props.theme.inputBoxHeight;
+}, function (props) {
+  return props.theme.inputPlaceholderColor;
+});
+export var InputBoxContainer = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  display: flex;\n  justify-content: space-between;\n\n  .color-select__input-group {\n    flex-grow: 1;\n  }\n  .color-select__input-group:nth-child(2) {\n    margin-left: 12px;\n  }\n"])));
+ColorSelectorFactory.deps = [ColorRangeSelectorFactory, RangeSliderFactory];
+function ColorSelectorFactory(ColorRangeSelector, RangeSlider) {
+  var ColorSelector = function ColorSelector(_ref) {
+    var _ref$colorSets = _ref.colorSets,
+      colorSets = _ref$colorSets === void 0 ? [] : _ref$colorSets,
+      colorUI = _ref.colorUI,
+      inputTheme = _ref.inputTheme,
+      disabled = _ref.disabled,
+      useOpacity = _ref.useOpacity,
+      setColorUI = _ref.setColorUI;
+    var _useState = useState(colorUI ? colorUI.showDropdown : false),
+      _useState2 = _slicedToArray(_useState, 2),
+      showDropdown = _useState2[0],
+      setShowDropdown = _useState2[1];
+    var showSketcher = colorUI ? colorUI.showSketcher : false;
+    var editingLookup = colorUI ? colorUI.showDropdown : showDropdown;
+    var editingColorSet = typeof editingLookup === 'number' && colorSets[editingLookup] ? colorSets[editingLookup] : false;
+    var closePanelDropdown = useCallback(function () {
+      if (editingLookup === false) {
+        return;
+      }
+      if (setColorUI) {
+        setColorUI({
+          showDropdown: false,
+          showSketcher: false
+        });
+      } else {
+        setShowDropdown(false);
+      }
+    }, [editingLookup, setColorUI, setShowDropdown]);
+    var handleClickOutside = useCallback(function () {
+      if (Number.isInteger(showSketcher)) {
+        // if sketcher is open, let sketch to close itself first
+        return;
+      }
+      closePanelDropdown();
+    }, [showSketcher, closePanelDropdown]);
+
+    // floating-ui boilerplate to establish close on outside click
+    var _useFloating = useFloating({
+        open: true,
+        onOpenChange: function onOpenChange(v) {
+          if (!v) {
+            handleClickOutside();
+          }
+        }
+      }),
+      refs = _useFloating.refs,
+      context = _useFloating.context;
+    var dismiss = useDismiss(context);
+    var _useInteractions = useInteractions([dismiss]),
+      getFloatingProps = _useInteractions.getFloatingProps;
+    var setColor = useCallback(function (colorSet, color, opacity) {
+      var _ref2 = colorSet || {},
+        setColor = _ref2.setColor;
+      if (!setColor) {
+        return;
+      }
+      if (useOpacity && Array.isArray(color)) {
+        setColor([].concat(_toConsumableArray(color.slice(0, 3)), [opacity]));
+      } else {
+        setColor(color);
+      }
+    }, [useOpacity]);
+    var onSelectColor = useCallback(function (color, e) {
+      if (e) e.stopPropagation();
+      var colorSet = editingColorSet;
+      if (colorSet) {
+        setColor(colorSet, color, colorSet.selectedColor[3]);
+      }
+    }, [editingColorSet, setColor]);
+    var onSelectOpacity = useCallback(function (opacity, e) {
+      if (e) e.stopPropagation();
+      var colorSet = editingColorSet;
+      if (colorSet) {
+        setColor(colorSet, colorSet.selectedColor, Math.round(opacity[1] * 255));
+      }
+    }, [editingColorSet, setColor]);
+    var onToggleDropdown = useCallback(function (e, i) {
+      e.stopPropagation();
+      e.preventDefault();
+      var showDropdownValue = editingLookup === false ? i // open it for the specific color set index
+      : false; // close it
+      if (setColorUI) {
+        setColorUI({
+          showDropdown: showDropdownValue
+        });
+      } else {
+        setShowDropdown(showDropdownValue);
+      }
+    }, [editingLookup, setColorUI, setShowDropdown]);
+    return /*#__PURE__*/React.createElement(StyledColorSelectorWrapper, _extends({
+      className: "color-selector",
+      ref: refs.setFloating
+    }, getFloatingProps()), /*#__PURE__*/React.createElement(InputBoxContainer, null, colorSets.map(function (cSet, i) {
+      return /*#__PURE__*/React.createElement("div", {
+        className: "color-select__input-group",
+        key: i
+      }, /*#__PURE__*/React.createElement(ColorSelectorInput, {
+        className: "color-selector__selector",
+        active: editingLookup === i,
+        disabled: disabled,
+        inputTheme: inputTheme,
+        onClick: function onClick(e) {
+          return onToggleDropdown(e, i);
+        }
+      }, cSet.isRange ? /*#__PURE__*/React.createElement(ColorPalette, {
+        colors: cSet.selectedColor.colors
+      }) : /*#__PURE__*/React.createElement(ColorBlock, {
+        className: "color-selector__selector__block",
+        backgroundcolor: cSet.selectedColor
+      }), cSet.label ? /*#__PURE__*/React.createElement("div", {
+        className: "color-selector__selector__label"
+      }, cSet.label) : null));
+    })), editingColorSet ? /*#__PURE__*/React.createElement(StyledPanelDropdown, {
+      className: "color-selector__dropdown"
+    }, editingColorSet.isRange && colorUI && setColorUI ? /*#__PURE__*/React.createElement(ColorRangeSelector, {
+      selectedColorRange: editingColorSet.selectedColor,
+      onSelectColorRange: onSelectColor,
+      setColorPaletteUI: setColorUI,
+      colorPaletteUI: colorUI
+    }) : /*#__PURE__*/React.createElement(SingleColorPalette, {
+      selectedColor: rgbToHex(editingColorSet.selectedColor),
+      onSelectColor: onSelectColor
+    }), useOpacity ? /*#__PURE__*/React.createElement(OpacitySliderWrapper, null, /*#__PURE__*/React.createElement(PanelLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: "color.opacity"
+    })), /*#__PURE__*/React.createElement(RangeSlider, _extends({}, OPACITY_SLIDER_PROPS, {
+      value1: editingColorSet.selectedColor[3] / 255,
+      onChange: onSelectOpacity
+    }))) : null) : null);
+  };
+  return ColorSelector;
+}
+export default ColorSelectorFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","FormattedMessage","styled","useDismiss","useFloating","useInteractions","rgbToHex","RangeSliderFactory","PanelLabel","shouldForwardProp","StyledPanelDropdown","ColorPalette","ColorRangeSelectorFactory","SingleColorPalette","OpacitySliderWrapper","div","_templateObject","_taggedTemplateLiteral","OPACITY_SLIDER_PROPS","type","range","value0","step","isRanged","label","showInput","ColorBlock","withConfig","_templateObject2","props","Array","isArray","backgroundcolor","concat","slice","join","StyledColorSelectorWrapper","_templateObject3","ColorSelectorInput","_templateObject4","inputTheme","theme","secondaryInput","input","inputBoxHeight","inputPlaceholderColor","InputBoxContainer","_templateObject5","ColorSelectorFactory","deps","ColorRangeSelector","RangeSlider","ColorSelector","_ref","_ref$colorSets","colorSets","colorUI","disabled","useOpacity","setColorUI","_useState","showDropdown","_useState2","_slicedToArray","setShowDropdown","showSketcher","editingLookup","editingColorSet","closePanelDropdown","handleClickOutside","Number","isInteger","_useFloating","open","onOpenChange","v","refs","context","dismiss","_useInteractions","getFloatingProps","setColor","colorSet","color","opacity","_ref2","_toConsumableArray","onSelectColor","e","stopPropagation","selectedColor","onSelectOpacity","Math","round","onToggleDropdown","i","preventDefault","showDropdownValue","createElement","_extends","className","ref","setFloating","map","cSet","key","active","onClick","isRange","colors","selectedColorRange","onSelectColorRange","setColorPaletteUI","colorPaletteUI","id","value1","onChange"],"sources":["../../../../src/side-panel/layer-panel/color-selector.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useState, MouseEvent} from 'react';\nimport {FormattedMessage} from 'react-intl';\nimport styled from 'styled-components';\nimport {useDismiss, useFloating, useInteractions} from '@floating-ui/react';\n\nimport {ColorRange} from '@kepler.gl/types';\nimport {ColorUI, NestedPartial, RGBAColor, RGBColor} from '@kepler.gl/types';\nimport {rgbToHex} from '@kepler.gl/utils';\n\nimport RangeSliderFactory from '../../common/range-slider';\nimport {PanelLabel, shouldForwardProp, StyledPanelDropdown} from '../../common/styled-components';\nimport ColorPalette from './color-palette';\nimport ColorRangeSelectorFactory from './color-range-selector';\nimport SingleColorPalette from './single-color-palette';\n\ntype ColorSelectorInputProps = {\n  active: boolean;\n  disabled?: boolean;\n  inputTheme?: string;\n};\n\nexport type ColorSet = {\n  selectedColor: RGBColor | RGBAColor | ColorRange;\n  setColor: (v: RGBColor | RGBAColor | ColorRange) => void;\n  isRange?: boolean;\n  label?: string;\n};\n\ntype ColorSelectorProps = {\n  colorSets: ColorSet[];\n  colorUI?: ColorUI;\n  inputTheme?: string;\n  disabled?: boolean;\n  useOpacity?: boolean;\n  setColorUI?: (newConfig: NestedPartial<ColorUI>) => void;\n};\n\nconst OpacitySliderWrapper = styled.div`\n  padding: 0px 12px 12px 12px;\n`;\n\nconst OPACITY_SLIDER_PROPS = {\n  type: 'number',\n  range: [0, 1],\n  value0: 0,\n  step: 0.01,\n  isRanged: false,\n  label: 'Opacity',\n  showInput: true\n};\n\nexport const ColorBlock = styled.div.withConfig({\n  shouldForwardProp\n})<{backgroundcolor: RGBColor}>`\n  width: 32px;\n  height: 18px;\n  border-radius: 1px;\n  background-color: ${props =>\n    Array.isArray(props.backgroundcolor)\n      ? `rgb(${props.backgroundcolor.slice(0, 3).join(',')})`\n      : 'transparent'};\n`;\n\nconst StyledColorSelectorWrapper = styled.div`\n  .selector__dropdown {\n    max-height: 600px; /* increase from the default 500px defined by StyledPanelDropdown */\n  }\n`;\n\nexport const ColorSelectorInput = styled.div.withConfig({\n  shouldForwardProp\n})<ColorSelectorInputProps>`\n  ${props => (props.inputTheme === 'secondary' ? props.theme.secondaryInput : props.theme.input)};\n  height: ${props => props.theme.inputBoxHeight};\n\n  .color-selector__selector__label {\n    text-transform: capitalize;\n    font-size: 12px;\n    text-align: center;\n    color: ${props => props.theme.inputPlaceholderColor};\n  }\n`;\n\nexport const InputBoxContainer = styled.div`\n  display: flex;\n  justify-content: space-between;\n\n  .color-select__input-group {\n    flex-grow: 1;\n  }\n  .color-select__input-group:nth-child(2) {\n    margin-left: 12px;\n  }\n`;\n\nColorSelectorFactory.deps = [ColorRangeSelectorFactory, RangeSliderFactory];\n\nfunction ColorSelectorFactory(\n  ColorRangeSelector: ReturnType<typeof ColorRangeSelectorFactory>,\n  RangeSlider: ReturnType<typeof RangeSliderFactory>\n): React.FC<ColorSelectorProps> {\n  const ColorSelector: React.FC<ColorSelectorProps> = ({\n    colorSets = [],\n    colorUI,\n    inputTheme,\n    disabled,\n    useOpacity,\n    setColorUI\n  }: ColorSelectorProps) => {\n    const [showDropdown, setShowDropdown] = useState(colorUI ? colorUI.showDropdown : false);\n    const showSketcher = colorUI ? colorUI.showSketcher : false;\n    const editingLookup = colorUI ? colorUI.showDropdown : showDropdown;\n    const editingColorSet: ColorSet | false =\n      typeof editingLookup === 'number' && colorSets[editingLookup]\n        ? colorSets[editingLookup]\n        : false;\n\n    const closePanelDropdown = useCallback(() => {\n      if (editingLookup === false) {\n        return;\n      }\n      if (setColorUI) {\n        setColorUI({showDropdown: false, showSketcher: false});\n      } else {\n        setShowDropdown(false);\n      }\n    }, [editingLookup, setColorUI, setShowDropdown]);\n\n    const handleClickOutside = useCallback(() => {\n      if (Number.isInteger(showSketcher)) {\n        // if sketcher is open, let sketch to close itself first\n        return;\n      }\n      closePanelDropdown();\n    }, [showSketcher, closePanelDropdown]);\n\n    // floating-ui boilerplate to establish close on outside click\n    const {refs, context} = useFloating({\n      open: true,\n      onOpenChange: v => {\n        if (!v) {\n          handleClickOutside();\n        }\n      }\n    });\n    const dismiss = useDismiss(context);\n    const {getFloatingProps} = useInteractions([dismiss]);\n\n    const setColor = useCallback(\n      (colorSet: ColorSet, color: RGBColor | RGBAColor | ColorRange, opacity: number) => {\n        const {setColor} = colorSet || {};\n        if (!setColor) {\n          return;\n        }\n        if (useOpacity && Array.isArray(color)) {\n          setColor([...color.slice(0, 3), opacity] as RGBAColor);\n        } else {\n          setColor(color);\n        }\n      },\n      [useOpacity]\n    );\n\n    const onSelectColor = useCallback(\n      (color: RGBColor | ColorRange, e: MouseEvent) => {\n        if (e) e.stopPropagation();\n        const colorSet = editingColorSet;\n        if (colorSet) {\n          setColor(colorSet, color, colorSet.selectedColor[3]);\n        }\n      },\n      [editingColorSet, setColor]\n    );\n\n    const onSelectOpacity = useCallback(\n      (opacity: number[], e: Event | null | undefined) => {\n        if (e) e.stopPropagation();\n        const colorSet = editingColorSet;\n        if (colorSet) {\n          setColor(colorSet, colorSet.selectedColor, Math.round(opacity[1] * 255));\n        }\n      },\n      [editingColorSet, setColor]\n    );\n\n    const onToggleDropdown = useCallback(\n      (e, i) => {\n        e.stopPropagation();\n        e.preventDefault();\n        const showDropdownValue =\n          editingLookup === false\n            ? i // open it for the specific color set index\n            : false; // close it\n        if (setColorUI) {\n          setColorUI({showDropdown: showDropdownValue});\n        } else {\n          setShowDropdown(showDropdownValue);\n        }\n      },\n      [editingLookup, setColorUI, setShowDropdown]\n    );\n\n    return (\n      <StyledColorSelectorWrapper\n        className=\"color-selector\"\n        ref={refs.setFloating}\n        {...getFloatingProps()}\n      >\n        <InputBoxContainer>\n          {colorSets.map((cSet, i) => (\n            <div className=\"color-select__input-group\" key={i}>\n              <ColorSelectorInput\n                className=\"color-selector__selector\"\n                active={editingLookup === i}\n                disabled={disabled}\n                inputTheme={inputTheme}\n                onClick={e => onToggleDropdown(e, i)}\n              >\n                {cSet.isRange ? (\n                  <ColorPalette colors={(cSet.selectedColor as ColorRange).colors} />\n                ) : (\n                  <ColorBlock\n                    className=\"color-selector__selector__block\"\n                    backgroundcolor={cSet.selectedColor as RGBColor}\n                  />\n                )}\n                {cSet.label ? (\n                  <div className=\"color-selector__selector__label\">{cSet.label}</div>\n                ) : null}\n              </ColorSelectorInput>\n            </div>\n          ))}\n        </InputBoxContainer>\n        {editingColorSet ? (\n          <StyledPanelDropdown className=\"color-selector__dropdown\">\n            {editingColorSet.isRange && colorUI && setColorUI ? (\n              <ColorRangeSelector\n                selectedColorRange={editingColorSet.selectedColor as ColorRange}\n                onSelectColorRange={onSelectColor}\n                setColorPaletteUI={setColorUI}\n                colorPaletteUI={colorUI as ColorUI}\n              />\n            ) : (\n              <SingleColorPalette\n                selectedColor={rgbToHex(editingColorSet.selectedColor as RGBColor)}\n                onSelectColor={onSelectColor}\n              />\n            )}\n            {useOpacity ? (\n              <OpacitySliderWrapper>\n                <PanelLabel>\n                  <FormattedMessage id=\"color.opacity\" />\n                </PanelLabel>\n                <RangeSlider\n                  {...OPACITY_SLIDER_PROPS}\n                  value1={editingColorSet.selectedColor[3] / 255}\n                  onChange={onSelectOpacity}\n                />\n              </OpacitySliderWrapper>\n            ) : null}\n          </StyledPanelDropdown>\n        ) : null}\n      </StyledColorSelectorWrapper>\n    );\n  };\n\n  return ColorSelector;\n}\n\nexport default ColorSelectorFactory;\n"],"mappings":"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","ignoreList":[]}