@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

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

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

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":[]}