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

package/dist/esm/editor/editor.js

@@ -0,0 +1,193 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component } from 'react';
+import { createPortal } from 'react-dom';
+import styled from 'styled-components';
+import Window from 'global/window';
+import classnames from 'classnames';
+import get from 'lodash/get';
+import { createSelector } from 'reselect';
+import FeatureActionPanelFactory from './feature-action-panel';
+import { EDITOR_AVAILABLE_LAYERS, FILTER_TYPES, EDITOR_MODES, GEOCODER_LAYER_ID, KeyEvent } from '@kepler.gl/constants';
+import { EditorLayerUtils } from '@kepler.gl/layers';
+import { RootContext } from '../context';
+var DECKGL_RENDER_LAYER = 'default-deckgl-overlay-wrapper';
+var StyledWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: relative;\n"])));
+var editorLayerFilter = function editorLayerFilter(layer) {
+  return EDITOR_AVAILABLE_LAYERS.includes(layer.type || '');
+};
+EditorFactory.deps = [FeatureActionPanelFactory];
+export default function EditorFactory(FeatureActionPanel) {
+  var PortalEditor = function PortalEditor(_ref) {
+    var visiblePanel = _ref.visiblePanel,
+      className = _ref.className,
+      style = _ref.style,
+      selectedFeature = _ref.selectedFeature,
+      datasets = _ref.datasets,
+      layers = _ref.layers,
+      currentFilter = _ref.currentFilter,
+      onClose = _ref.onClose,
+      onDeleteFeature = _ref.onDeleteFeature,
+      onToggleLayer = _ref.onToggleLayer,
+      position = _ref.position;
+    return /*#__PURE__*/React.createElement(RootContext.Consumer, null, function (context) {
+      var _context$current;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/createPortal(/*#__PURE__*/React.createElement(StyledWrapper, {
+        className: classnames('editor', className),
+        style: style
+      }, visiblePanel ? /*#__PURE__*/React.createElement(FeatureActionPanel, {
+        selectedFeature: selectedFeature,
+        datasets: datasets,
+        layers: layers,
+        currentFilter: currentFilter,
+        onClose: onClose,
+        onDeleteFeature: onDeleteFeature,
+        onToggleLayer: onToggleLayer,
+        position: position || null
+      }) : null), (_context$current = context === null || context === void 0 ? void 0 : context.current) !== null && _context$current !== void 0 ? _context$current : document.body));
+    });
+  };
+  var EditorUnmemoized = /*#__PURE__*/function (_Component) {
+    function EditorUnmemoized() {
+      var _this;
+      _classCallCheck(this, EditorUnmemoized);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, EditorUnmemoized, [].concat(args));
+      _defineProperty(_this, "state", {});
+      _defineProperty(_this, "layerSelector", function (props) {
+        return props.layers;
+      });
+      _defineProperty(_this, "filterSelector", function (props) {
+        return props.filters;
+      });
+      _defineProperty(_this, "selectedFeatureIdSelector", function (props) {
+        return get(props, ['editor', 'selectedFeature', 'id']);
+      });
+      _defineProperty(_this, "editorFeatureSelector", function (props) {
+        return get(props, ['editor', 'features']);
+      });
+      _defineProperty(_this, "currentFilterSelector", createSelector(_this.filterSelector, _this.selectedFeatureIdSelector, function (filters, selectedFeatureId) {
+        return filters.find(function (f) {
+          return f.value && f.value.id === selectedFeatureId;
+        });
+      }));
+      _defineProperty(_this, "availableLayersSelector", createSelector(_this.layerSelector, function (layers) {
+        return layers.filter(editorLayerFilter).filter(function (layer) {
+          var _layer$config;
+          return ((_layer$config = layer.config) === null || _layer$config === void 0 ? void 0 : _layer$config.isVisible) && layer.id !== GEOCODER_LAYER_ID;
+        });
+      }));
+      _defineProperty(_this, "allFeaturesSelector", createSelector(_this.filterSelector, _this.editorFeatureSelector, function (filters, editorFeatures) {
+        return filters.filter(function (f) {
+          return f.type === FILTER_TYPES.polygon;
+        }).map(function (f) {
+          return f.value;
+        }).concat(editorFeatures);
+      }));
+      _defineProperty(_this, "isInFocus", function () {
+        var _document$activeEleme;
+        return ((_document$activeEleme = document.activeElement) === null || _document$activeEleme === void 0 ? void 0 : _document$activeEleme.id) === DECKGL_RENDER_LAYER;
+      });
+      _defineProperty(_this, "_onKeyPressed", function (event) {
+        if (_this.isInFocus()) {
+          switch (event.keyCode) {
+            case KeyEvent.DOM_VK_DELETE:
+            case KeyEvent.DOM_VK_BACK_SPACE:
+              _this._onDeleteSelectedFeature();
+              break;
+            case KeyEvent.DOM_VK_ESCAPE:
+              // reset active drawing
+              if (EditorLayerUtils.isDrawingActive(true, _this.props.editor.mode)) {
+                _this.props.onSetEditorMode(EDITOR_MODES.EDIT);
+              }
+              _this.props.onSelect(null);
+              break;
+            default:
+              break;
+          }
+        }
+      });
+      _defineProperty(_this, "_onDeleteSelectedFeature", function () {
+        var editor = _this.props.editor;
+        var selectedFeature = editor.selectedFeature;
+        if (selectedFeature) {
+          _this.props.onDeleteFeature(selectedFeature);
+        }
+      });
+      _defineProperty(_this, "_closeFeatureAction", function () {
+        // reset selection context
+        var selectedFeature = _this.props.editor.selectedFeature;
+        _this.props.onSelect(selectedFeature);
+      });
+      _defineProperty(_this, "_togglePolygonFilter", function (layer) {
+        var selectedFeature = _this.props.editor.selectedFeature;
+        if (selectedFeature) {
+          _this.props.onTogglePolygonFilter(layer, selectedFeature);
+        }
+      });
+      return _this;
+    }
+    _inherits(EditorUnmemoized, _Component);
+    return _createClass(EditorUnmemoized, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        Window.addEventListener('keydown', this._onKeyPressed);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        Window.removeEventListener('keydown', this._onKeyPressed);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+          className = _this$props.className,
+          datasets = _this$props.datasets,
+          editor = _this$props.editor,
+          style = _this$props.style,
+          index = _this$props.index;
+        var selectedFeature = editor.selectedFeature,
+          selectionContext = editor.selectionContext;
+        var currentFilter = this.currentFilterSelector(this.props);
+        var availableLayers = this.availableLayersSelector(this.props);
+        var _ref2 = selectionContext || {},
+          rightClick = _ref2.rightClick,
+          position = _ref2.position,
+          mapIndex = _ref2.mapIndex;
+        return /*#__PURE__*/React.createElement(PortalEditor, {
+          selectedFeature: selectedFeature,
+          visiblePanel: Boolean(rightClick) && selectedFeature && index === mapIndex,
+          datasets: datasets,
+          layers: availableLayers,
+          currentFilter: currentFilter,
+          onClose: this._closeFeatureAction,
+          onDeleteFeature: this._onDeleteSelectedFeature,
+          onToggleLayer: this._togglePolygonFilter,
+          position: position || null,
+          className: className,
+          style: style
+        });
+      }
+    }]);
+  }(Component);
+  _defineProperty(EditorUnmemoized, "defaultProps", {});
+  _defineProperty(EditorUnmemoized, "displayName", 'Editor');
+  var Editor = /*#__PURE__*/React.memo(EditorUnmemoized);
+  Editor.displayName = 'Editor';
+  return Editor;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createPortal","styled","Window","classnames","get","createSelector","FeatureActionPanelFactory","EDITOR_AVAILABLE_LAYERS","FILTER_TYPES","EDITOR_MODES","GEOCODER_LAYER_ID","KeyEvent","EditorLayerUtils","RootContext","DECKGL_RENDER_LAYER","StyledWrapper","div","_templateObject","_taggedTemplateLiteral","editorLayerFilter","layer","includes","type","EditorFactory","deps","FeatureActionPanel","PortalEditor","_ref","visiblePanel","className","style","selectedFeature","datasets","layers","currentFilter","onClose","onDeleteFeature","onToggleLayer","position","createElement","Consumer","context","_context$current","Fragment","current","document","body","EditorUnmemoized","_Component","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","_defineProperty","props","filters","filterSelector","selectedFeatureIdSelector","selectedFeatureId","find","f","value","id","layerSelector","filter","_layer$config","config","isVisible","editorFeatureSelector","editorFeatures","polygon","map","_document$activeEleme","activeElement","event","isInFocus","keyCode","DOM_VK_DELETE","DOM_VK_BACK_SPACE","_onDeleteSelectedFeature","DOM_VK_ESCAPE","isDrawingActive","editor","mode","onSetEditorMode","EDIT","onSelect","onTogglePolygonFilter","_inherits","_createClass","key","componentDidMount","addEventListener","_onKeyPressed","componentWillUnmount","removeEventListener","render","_this$props","index","selectionContext","currentFilterSelector","availableLayers","availableLayersSelector","_ref2","rightClick","mapIndex","Boolean","_closeFeatureAction","_togglePolygonFilter","Editor","memo","displayName"],"sources":["../../../src/editor/editor.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, CSSProperties, KeyboardEvent} from 'react';\nimport {createPortal} from 'react-dom';\nimport styled from 'styled-components';\nimport Window from 'global/window';\nimport classnames from 'classnames';\nimport get from 'lodash/get';\nimport {createSelector} from 'reselect';\nimport FeatureActionPanelFactory, {FeatureActionPanelProps} from './feature-action-panel';\nimport {\n  EDITOR_AVAILABLE_LAYERS,\n  FILTER_TYPES,\n  EDITOR_MODES,\n  GEOCODER_LAYER_ID,\n  KeyEvent\n} from '@kepler.gl/constants';\nimport {Layer, EditorLayerUtils} from '@kepler.gl/layers';\nimport {Filter, FeatureSelectionContext, Feature} from '@kepler.gl/types';\nimport {Feature as EditableFeature, Polygon} from '@deck.gl-community/editable-layers';\nimport {Datasets} from '@kepler.gl/table';\n\nimport {RootContext} from '../context';\n\nconst DECKGL_RENDER_LAYER = 'default-deckgl-overlay-wrapper';\n\nconst StyledWrapper = styled.div`\n  position: relative;\n`;\n\nconst editorLayerFilter = (layer: Layer) => EDITOR_AVAILABLE_LAYERS.includes(layer.type || '');\n\nEditorFactory.deps = [FeatureActionPanelFactory];\n\ninterface EditorProps {\n  filters: Filter[];\n  layers: Layer[];\n  datasets: Datasets;\n  editor: {selectedFeature: Feature; mode: string; selectionContext?: FeatureSelectionContext};\n  index: number;\n  className?: string;\n  style: CSSProperties;\n  onSelect: (f: Feature | null) => any;\n  onSetEditorMode: (m: any) => void;\n  onDeleteFeature: (f: Feature) => any;\n  onTogglePolygonFilter: (l: Layer, f: Feature) => any;\n}\n\nexport type PortalEditorProps = FeatureActionPanelProps & {\n  visiblePanel: boolean;\n  style?: React.CSSProperties;\n};\n\nexport default function EditorFactory(\n  FeatureActionPanel: React.FC<FeatureActionPanelProps>\n): React.ComponentClass<EditorProps> {\n  const PortalEditor: React.FC<PortalEditorProps> = ({\n    visiblePanel,\n    className,\n    style,\n    selectedFeature,\n    datasets,\n    layers,\n    currentFilter,\n    onClose,\n    onDeleteFeature,\n    onToggleLayer,\n    position\n  }) => {\n    return (\n      <RootContext.Consumer>\n        {context => (\n          <>\n            {createPortal(\n              <StyledWrapper className={classnames('editor', className)} style={style}>\n                {visiblePanel ? (\n                  <FeatureActionPanel\n                    selectedFeature={selectedFeature as EditableFeature<Polygon>}\n                    datasets={datasets}\n                    layers={layers}\n                    currentFilter={currentFilter}\n                    onClose={onClose}\n                    onDeleteFeature={onDeleteFeature}\n                    onToggleLayer={onToggleLayer}\n                    position={position || null}\n                  />\n                ) : null}\n              </StyledWrapper>,\n              context?.current ?? document.body\n            )}\n          </>\n        )}\n      </RootContext.Consumer>\n    );\n  };\n  class EditorUnmemoized extends Component<EditorProps> {\n    static defaultProps = {};\n\n    static displayName = 'Editor';\n\n    state = {};\n\n    componentDidMount() {\n      Window.addEventListener('keydown', this._onKeyPressed);\n    }\n\n    componentWillUnmount() {\n      Window.removeEventListener('keydown', this._onKeyPressed);\n    }\n\n    layerSelector = (props: EditorProps) => props.layers;\n    filterSelector = (props: EditorProps) => props.filters;\n    selectedFeatureIdSelector = (props: EditorProps) =>\n      get(props, ['editor', 'selectedFeature', 'id']);\n    editorFeatureSelector = (props: EditorProps) => get(props, ['editor', 'features']);\n\n    currentFilterSelector = createSelector(\n      this.filterSelector,\n      this.selectedFeatureIdSelector,\n      (filters, selectedFeatureId) => filters.find(f => f.value && f.value.id === selectedFeatureId)\n    );\n\n    availableLayersSelector = createSelector(this.layerSelector, layers =>\n      layers\n        .filter(editorLayerFilter)\n        .filter(layer => layer.config?.isVisible && layer.id !== GEOCODER_LAYER_ID)\n    );\n\n    allFeaturesSelector = createSelector(\n      this.filterSelector,\n      this.editorFeatureSelector,\n      (filters, editorFeatures) =>\n        filters\n          .filter(f => f.type === FILTER_TYPES.polygon)\n          .map(f => f.value)\n          .concat(editorFeatures)\n    );\n\n    isInFocus = () => document.activeElement?.id === DECKGL_RENDER_LAYER;\n\n    _onKeyPressed = (event: KeyboardEvent) => {\n      if (this.isInFocus()) {\n        switch (event.keyCode) {\n          case KeyEvent.DOM_VK_DELETE:\n          case KeyEvent.DOM_VK_BACK_SPACE:\n            this._onDeleteSelectedFeature();\n            break;\n          case KeyEvent.DOM_VK_ESCAPE:\n            // reset active drawing\n            if (EditorLayerUtils.isDrawingActive(true, this.props.editor.mode)) {\n              this.props.onSetEditorMode(EDITOR_MODES.EDIT);\n            }\n\n            this.props.onSelect(null);\n            break;\n          default:\n            break;\n        }\n      }\n    };\n\n    _onDeleteSelectedFeature = () => {\n      const {editor} = this.props;\n      const {selectedFeature} = editor;\n      if (selectedFeature) {\n        this.props.onDeleteFeature(selectedFeature);\n      }\n    };\n\n    _closeFeatureAction = () => {\n      // reset selection context\n      const {selectedFeature} = this.props.editor;\n      this.props.onSelect(selectedFeature);\n    };\n\n    _togglePolygonFilter = (layer: Layer) => {\n      const {selectedFeature} = this.props.editor;\n      if (selectedFeature) {\n        this.props.onTogglePolygonFilter(layer, selectedFeature);\n      }\n    };\n\n    render() {\n      const {className, datasets, editor, style, index} = this.props;\n      const {selectedFeature, selectionContext} = editor;\n      const currentFilter = this.currentFilterSelector(this.props);\n      const availableLayers = this.availableLayersSelector(this.props);\n\n      const {rightClick, position, mapIndex} = selectionContext || {};\n\n      return (\n        <PortalEditor\n          selectedFeature={selectedFeature as EditableFeature<Polygon>}\n          visiblePanel={Boolean(rightClick) && selectedFeature && index === mapIndex}\n          datasets={datasets}\n          layers={availableLayers}\n          currentFilter={currentFilter}\n          onClose={this._closeFeatureAction}\n          onDeleteFeature={this._onDeleteSelectedFeature}\n          onToggleLayer={this._togglePolygonFilter}\n          position={position || null}\n          className={className}\n          style={style}\n        />\n      );\n    }\n  }\n\n  const Editor = React.memo(EditorUnmemoized) as unknown as typeof EditorUnmemoized;\n  Editor.displayName = 'Editor';\n  return Editor;\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAGC,SAAS,QAAqC,OAAO;AACpE,SAAQC,YAAY,QAAO,WAAW;AACtC,OAAOC,MAAM,MAAM,mBAAmB;AACtC,OAAOC,MAAM,MAAM,eAAe;AAClC,OAAOC,UAAU,MAAM,YAAY;AACnC,OAAOC,GAAG,MAAM,YAAY;AAC5B,SAAQC,cAAc,QAAO,UAAU;AACvC,OAAOC,yBAAyB,MAAiC,wBAAwB;AACzF,SACEC,uBAAuB,EACvBC,YAAY,EACZC,YAAY,EACZC,iBAAiB,EACjBC,QAAQ,QACH,sBAAsB;AAC7B,SAAeC,gBAAgB,QAAO,mBAAmB;AAKzD,SAAQC,WAAW,QAAO,YAAY;AAEtC,IAAMC,mBAAmB,GAAG,gCAAgC;AAE5D,IAAMC,aAAa,GAAGd,MAAM,CAACe,GAAG,CAAAC,eAAA,KAAAA,eAAA,GAAAC,sBAAA,iCAE/B;AAED,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAAIC,KAAY;EAAA,OAAKb,uBAAuB,CAACc,QAAQ,CAACD,KAAK,CAACE,IAAI,IAAI,EAAE,CAAC;AAAA;AAE9FC,aAAa,CAACC,IAAI,GAAG,CAAClB,yBAAyB,CAAC;AAqBhD,eAAe,SAASiB,aAAaA,CACnCE,kBAAqD,EAClB;EACnC,IAAMC,YAAyC,GAAG,SAA5CA,YAAyCA,CAAAC,IAAA,EAYzC;IAAA,IAXJC,YAAY,GAAAD,IAAA,CAAZC,YAAY;MACZC,SAAS,GAAAF,IAAA,CAATE,SAAS;MACTC,KAAK,GAAAH,IAAA,CAALG,KAAK;MACLC,eAAe,GAAAJ,IAAA,CAAfI,eAAe;MACfC,QAAQ,GAAAL,IAAA,CAARK,QAAQ;MACRC,MAAM,GAAAN,IAAA,CAANM,MAAM;MACNC,aAAa,GAAAP,IAAA,CAAbO,aAAa;MACbC,OAAO,GAAAR,IAAA,CAAPQ,OAAO;MACPC,eAAe,GAAAT,IAAA,CAAfS,eAAe;MACfC,aAAa,GAAAV,IAAA,CAAbU,aAAa;MACbC,QAAQ,GAAAX,IAAA,CAARW,QAAQ;IAER,oBACExC,KAAA,CAAAyC,aAAA,CAAC1B,WAAW,CAAC2B,QAAQ,QAClB,UAAAC,OAAO;MAAA,IAAAC,gBAAA;MAAA,oBACN5C,KAAA,CAAAyC,aAAA,CAAAzC,KAAA,CAAA6C,QAAA,qBACG3C,YAAY,cACXF,KAAA,CAAAyC,aAAA,CAACxB,aAAa;QAACc,SAAS,EAAE1B,UAAU,CAAC,QAAQ,EAAE0B,SAAS,CAAE;QAACC,KAAK,EAAEA;MAAM,GACrEF,YAAY,gBACX9B,KAAA,CAAAyC,aAAA,CAACd,kBAAkB;QACjBM,eAAe,EAAEA,eAA4C;QAC7DC,QAAQ,EAAEA,QAAS;QACnBC,MAAM,EAAEA,MAAO;QACfC,aAAa,EAAEA,aAAc;QAC7BC,OAAO,EAAEA,OAAQ;QACjBC,eAAe,EAAEA,eAAgB;QACjCC,aAAa,EAAEA,aAAc;QAC7BC,QAAQ,EAAEA,QAAQ,IAAI;MAAK,CAC5B,CAAC,GACA,IACS,CAAC,GAAAI,gBAAA,GAChBD,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEG,OAAO,cAAAF,gBAAA,cAAAA,gBAAA,GAAIG,QAAQ,CAACC,IAC/B,CACA,CAAC;IAAA,CAEe,CAAC;EAE3B,CAAC;EAAC,IACIC,gBAAgB,0BAAAC,UAAA;IAAA,SAAAD,iBAAA;MAAA,IAAAE,KAAA;MAAAC,eAAA,OAAAH,gBAAA;MAAA,SAAAI,IAAA,GAAAC,SAAA,CAAAC,MAAA,EAAAC,IAAA,OAAAC,KAAA,CAAAJ,IAAA,GAAAK,IAAA,MAAAA,IAAA,GAAAL,IAAA,EAAAK,IAAA;QAAAF,IAAA,CAAAE,IAAA,IAAAJ,SAAA,CAAAI,IAAA;MAAA;MAAAP,KAAA,GAAAQ,UAAA,OAAAV,gBAAA,KAAAW,MAAA,CAAAJ,IAAA;MAAAK,eAAA,CAAAV,KAAA,WAKZ,CAAC,CAAC;MAAAU,eAAA,CAAAV,KAAA,mBAUM,UAACW,KAAkB;QAAA,OAAKA,KAAK,CAAC3B,MAAM;MAAA;MAAA0B,eAAA,CAAAV,KAAA,oBACnC,UAACW,KAAkB;QAAA,OAAKA,KAAK,CAACC,OAAO;MAAA;MAAAF,eAAA,CAAAV,KAAA,+BAC1B,UAACW,KAAkB;QAAA,OAC7CxD,GAAG,CAACwD,KAAK,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,CAAC,CAAC;MAAA;MAAAD,eAAA,CAAAV,KAAA,2BACzB,UAACW,KAAkB;QAAA,OAAKxD,GAAG,CAACwD,KAAK,EAAE,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;MAAA;MAAAD,eAAA,CAAAV,KAAA,2BAE1D5C,cAAc,CACpC4C,KAAA,CAAKa,cAAc,EACnBb,KAAA,CAAKc,yBAAyB,EAC9B,UAACF,OAAO,EAAEG,iBAAiB;QAAA,OAAKH,OAAO,CAACI,IAAI,CAAC,UAAAC,CAAC;UAAA,OAAIA,CAAC,CAACC,KAAK,IAAID,CAAC,CAACC,KAAK,CAACC,EAAE,KAAKJ,iBAAiB;QAAA,EAAC;MAAA,CAChG,CAAC;MAAAL,eAAA,CAAAV,KAAA,6BAEyB5C,cAAc,CAAC4C,KAAA,CAAKoB,aAAa,EAAE,UAAApC,MAAM;QAAA,OACjEA,MAAM,CACHqC,MAAM,CAACnD,iBAAiB,CAAC,CACzBmD,MAAM,CAAC,UAAAlD,KAAK;UAAA,IAAAmD,aAAA;UAAA,OAAI,EAAAA,aAAA,GAAAnD,KAAK,CAACoD,MAAM,cAAAD,aAAA,uBAAZA,aAAA,CAAcE,SAAS,KAAIrD,KAAK,CAACgD,EAAE,KAAK1D,iBAAiB;QAAA,EAAC;MAAA,CAC/E,CAAC;MAAAiD,eAAA,CAAAV,KAAA,yBAEqB5C,cAAc,CAClC4C,KAAA,CAAKa,cAAc,EACnBb,KAAA,CAAKyB,qBAAqB,EAC1B,UAACb,OAAO,EAAEc,cAAc;QAAA,OACtBd,OAAO,CACJS,MAAM,CAAC,UAAAJ,CAAC;UAAA,OAAIA,CAAC,CAAC5C,IAAI,KAAKd,YAAY,CAACoE,OAAO;QAAA,EAAC,CAC5CC,GAAG,CAAC,UAAAX,CAAC;UAAA,OAAIA,CAAC,CAACC,KAAK;QAAA,EAAC,CACjBT,MAAM,CAACiB,cAAc,CAAC;MAAA,CAC7B,CAAC;MAAAhB,eAAA,CAAAV,KAAA,eAEW;QAAA,IAAA6B,qBAAA;QAAA,OAAM,EAAAA,qBAAA,GAAAjC,QAAQ,CAACkC,aAAa,cAAAD,qBAAA,uBAAtBA,qBAAA,CAAwBV,EAAE,MAAKtD,mBAAmB;MAAA;MAAA6C,eAAA,CAAAV,KAAA,mBAEpD,UAAC+B,KAAoB,EAAK;QACxC,IAAI/B,KAAA,CAAKgC,SAAS,CAAC,CAAC,EAAE;UACpB,QAAQD,KAAK,CAACE,OAAO;YACnB,KAAKvE,QAAQ,CAACwE,aAAa;YAC3B,KAAKxE,QAAQ,CAACyE,iBAAiB;cAC7BnC,KAAA,CAAKoC,wBAAwB,CAAC,CAAC;cAC/B;YACF,KAAK1E,QAAQ,CAAC2E,aAAa;cACzB;cACA,IAAI1E,gBAAgB,CAAC2E,eAAe,CAAC,IAAI,EAAEtC,KAAA,CAAKW,KAAK,CAAC4B,MAAM,CAACC,IAAI,CAAC,EAAE;gBAClExC,KAAA,CAAKW,KAAK,CAAC8B,eAAe,CAACjF,YAAY,CAACkF,IAAI,CAAC;cAC/C;cAEA1C,KAAA,CAAKW,KAAK,CAACgC,QAAQ,CAAC,IAAI,CAAC;cACzB;YACF;cACE;UACJ;QACF;MACF,CAAC;MAAAjC,eAAA,CAAAV,KAAA,8BAE0B,YAAM;QAC/B,IAAOuC,MAAM,GAAIvC,KAAA,CAAKW,KAAK,CAApB4B,MAAM;QACb,IAAOzD,eAAe,GAAIyD,MAAM,CAAzBzD,eAAe;QACtB,IAAIA,eAAe,EAAE;UACnBkB,KAAA,CAAKW,KAAK,CAACxB,eAAe,CAACL,eAAe,CAAC;QAC7C;MACF,CAAC;MAAA4B,eAAA,CAAAV,KAAA,yBAEqB,YAAM;QAC1B;QACA,IAAOlB,eAAe,GAAIkB,KAAA,CAAKW,KAAK,CAAC4B,MAAM,CAApCzD,eAAe;QACtBkB,KAAA,CAAKW,KAAK,CAACgC,QAAQ,CAAC7D,eAAe,CAAC;MACtC,CAAC;MAAA4B,eAAA,CAAAV,KAAA,0BAEsB,UAAC7B,KAAY,EAAK;QACvC,IAAOW,eAAe,GAAIkB,KAAA,CAAKW,KAAK,CAAC4B,MAAM,CAApCzD,eAAe;QACtB,IAAIA,eAAe,EAAE;UACnBkB,KAAA,CAAKW,KAAK,CAACiC,qBAAqB,CAACzE,KAAK,EAAEW,eAAe,CAAC;QAC1D;MACF,CAAC;MAAA,OAAAkB,KAAA;IAAA;IAAA6C,SAAA,CAAA/C,gBAAA,EAAAC,UAAA;IAAA,OAAA+C,YAAA,CAAAhD,gBAAA;MAAAiD,GAAA;MAAA7B,KAAA,EA9ED,SAAA8B,iBAAiBA,CAAA,EAAG;QAClB/F,MAAM,CAACgG,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAACC,aAAa,CAAC;MACxD;IAAC;MAAAH,GAAA;MAAA7B,KAAA,EAED,SAAAiC,oBAAoBA,CAAA,EAAG;QACrBlG,MAAM,CAACmG,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAACF,aAAa,CAAC;MAC3D;IAAC;MAAAH,GAAA;MAAA7B,KAAA,EA0ED,SAAAmC,MAAMA,CAAA,EAAG;QACP,IAAAC,WAAA,GAAoD,IAAI,CAAC3C,KAAK;UAAvD/B,SAAS,GAAA0E,WAAA,CAAT1E,SAAS;UAAEG,QAAQ,GAAAuE,WAAA,CAARvE,QAAQ;UAAEwD,MAAM,GAAAe,WAAA,CAANf,MAAM;UAAE1D,KAAK,GAAAyE,WAAA,CAALzE,KAAK;UAAE0E,KAAK,GAAAD,WAAA,CAALC,KAAK;QAChD,IAAOzE,eAAe,GAAsByD,MAAM,CAA3CzD,eAAe;UAAE0E,gBAAgB,GAAIjB,MAAM,CAA1BiB,gBAAgB;QACxC,IAAMvE,aAAa,GAAG,IAAI,CAACwE,qBAAqB,CAAC,IAAI,CAAC9C,KAAK,CAAC;QAC5D,IAAM+C,eAAe,GAAG,IAAI,CAACC,uBAAuB,CAAC,IAAI,CAAChD,KAAK,CAAC;QAEhE,IAAAiD,KAAA,GAAyCJ,gBAAgB,IAAI,CAAC,CAAC;UAAxDK,UAAU,GAAAD,KAAA,CAAVC,UAAU;UAAExE,QAAQ,GAAAuE,KAAA,CAARvE,QAAQ;UAAEyE,QAAQ,GAAAF,KAAA,CAARE,QAAQ;QAErC,oBACEjH,KAAA,CAAAyC,aAAA,CAACb,YAAY;UACXK,eAAe,EAAEA,eAA4C;UAC7DH,YAAY,EAAEoF,OAAO,CAACF,UAAU,CAAC,IAAI/E,eAAe,IAAIyE,KAAK,KAAKO,QAAS;UAC3E/E,QAAQ,EAAEA,QAAS;UACnBC,MAAM,EAAE0E,eAAgB;UACxBzE,aAAa,EAAEA,aAAc;UAC7BC,OAAO,EAAE,IAAI,CAAC8E,mBAAoB;UAClC7E,eAAe,EAAE,IAAI,CAACiD,wBAAyB;UAC/ChD,aAAa,EAAE,IAAI,CAAC6E,oBAAqB;UACzC5E,QAAQ,EAAEA,QAAQ,IAAI,IAAK;UAC3BT,SAAS,EAAEA,SAAU;UACrBC,KAAK,EAAEA;QAAM,CACd,CAAC;MAEN;IAAC;EAAA,EA9G4B/B,SAAS;EAAA4D,eAAA,CAAlCZ,gBAAgB,kBACE,CAAC,CAAC;EAAAY,eAAA,CADpBZ,gBAAgB,iBAGC,QAAQ;EA8G/B,IAAMoE,MAAM,gBAAGrH,KAAK,CAACsH,IAAI,CAACrE,gBAAgB,CAAuC;EACjFoE,MAAM,CAACE,WAAW,GAAG,QAAQ;EAC7B,OAAOF,MAAM;AACf","ignoreList":[]}

package/dist/esm/editor/feature-action-panel.js

@@ -0,0 +1,139 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useState } from 'react';
+import { useIntl } from 'react-intl';
+import copy from 'copy-to-clipboard';
+import { useDismiss, useFloating, useInteractions } from '@floating-ui/react';
+import classnames from 'classnames';
+import styled from 'styled-components';
+import { canApplyFeatureFilter } from '@kepler.gl/utils';
+import ActionPanel, { ActionPanelItem } from '../common/action-panel';
+import { Trash, Layers, Copy, Checkmark } from '../common/icons';
+var LAYOVER_OFFSET = 4;
+var StyledActionsLayer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: absolute;\n  .layer-panel-item-disabled {\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.textColor;
+});
+var defaultActionIcons = {
+  remove: Trash,
+  layer: Layers,
+  copy: Copy,
+  copied: Checkmark
+};
+PureFeatureActionPanelFactory.deps = [];
+export function PureFeatureActionPanelFactory() {
+  var FeatureActionPanel = function FeatureActionPanel(_ref) {
+    var className = _ref.className,
+      datasets = _ref.datasets,
+      selectedFeature = _ref.selectedFeature,
+      _ref$position = _ref.position,
+      position = _ref$position === void 0 ? null : _ref$position,
+      layers = _ref.layers,
+      currentFilter = _ref.currentFilter,
+      onToggleLayer = _ref.onToggleLayer,
+      onDeleteFeature = _ref.onDeleteFeature,
+      _ref$actionIcons = _ref.actionIcons,
+      actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons,
+      children = _ref.children,
+      onClose = _ref.onClose;
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      copied = _useState2[0],
+      setCopied = _useState2[1];
+    var _ref2 = currentFilter || {},
+      _ref2$layerId = _ref2.layerId,
+      layerId = _ref2$layerId === void 0 ? [] : _ref2$layerId;
+    var intl = useIntl();
+    var _useFloating = useFloating({
+        open: true,
+        onOpenChange: function onOpenChange(v) {
+          if (!v && onClose) {
+            onClose();
+          }
+        }
+      }),
+      refs = _useFloating.refs,
+      context = _useFloating.context;
+    var dismiss = useDismiss(context);
+    var _useInteractions = useInteractions([dismiss]),
+      getFloatingProps = _useInteractions.getFloatingProps;
+    var copyGeometry = useCallback(function () {
+      if (selectedFeature !== null && selectedFeature !== void 0 && selectedFeature.geometry) copy(JSON.stringify(selectedFeature.geometry));
+      setCopied(true);
+    }, [selectedFeature === null || selectedFeature === void 0 ? void 0 : selectedFeature.geometry]);
+    if (!position) {
+      return null;
+    }
+    var isFilterLayerDisabled = !canApplyFeatureFilter(selectedFeature);
+    return /*#__PURE__*/React.createElement(StyledActionsLayer, _extends({
+      ref: refs.setFloating
+    }, getFloatingProps(), {
+      className: classnames('feature-action-panel', className),
+      style: {
+        top: "".concat(position.y + LAYOVER_OFFSET, "px"),
+        left: "".concat(position.x + LAYOVER_OFFSET, "px")
+      }
+    }), /*#__PURE__*/React.createElement(ActionPanel, null, /*#__PURE__*/React.createElement(ActionPanelItem, {
+      className: "editor-layers-list",
+      label: intl.formatMessage({
+        id: 'editor.filterLayer',
+        defaultMessage: 'Filter layers'
+      }),
+      Icon: actionIcons.layer,
+      isDisabled: isFilterLayerDisabled,
+      tooltipText: isFilterLayerDisabled ? intl.formatMessage({
+        id: 'editor.filterLayerDisabled'
+      }) : null
+    }, layers.length ? layers.map(function (layer, index) {
+      return /*#__PURE__*/React.createElement(ActionPanelItem, {
+        key: index,
+        label: layer.config.label
+        // @ts-ignore
+        ,
+        color: datasets[layer.config.dataId].color,
+        isSelection: true,
+        isActive: layerId.includes(layer.id),
+        onClick: function onClick() {
+          return onToggleLayer(layer);
+        },
+        className: "layer-panel-item"
+      });
+    }) : /*#__PURE__*/React.createElement(ActionPanelItem, {
+      key: 'no-layers',
+      label: intl.formatMessage({
+        id: 'editor.noLayersToFilter',
+        defaultMessage: 'No layers to filter'
+      }),
+      isSelection: false,
+      isActive: false,
+      className: "layer-panel-item-disabled"
+    })), /*#__PURE__*/React.createElement(ActionPanelItem, {
+      label: intl.formatMessage({
+        id: 'editor.copyGeometry',
+        defaultMessage: 'Copy Geometry'
+      }),
+      className: "delete-panel-item",
+      Icon: copied ? actionIcons.copied : actionIcons.copy,
+      onClick: copyGeometry
+    }), children, /*#__PURE__*/React.createElement(ActionPanelItem, {
+      label: intl.formatMessage({
+        id: 'tooltip.delete',
+        defaultMessage: 'Delete'
+      }),
+      className: "delete-panel-item",
+      Icon: actionIcons.remove,
+      onClick: onDeleteFeature
+    })));
+  };
+  FeatureActionPanel.displayName = 'FeatureActionPanel';
+  return FeatureActionPanel;
+}
+FeatureActionPanelFactory.deps = PureFeatureActionPanelFactory.deps;
+export default function FeatureActionPanelFactory() {
+  return PureFeatureActionPanelFactory();
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","useIntl","copy","useDismiss","useFloating","useInteractions","classnames","styled","canApplyFeatureFilter","ActionPanel","ActionPanelItem","Trash","Layers","Copy","Checkmark","LAYOVER_OFFSET","StyledActionsLayer","div","_templateObject","_taggedTemplateLiteral","props","theme","textColor","defaultActionIcons","remove","layer","copied","PureFeatureActionPanelFactory","deps","FeatureActionPanel","_ref","className","datasets","selectedFeature","_ref$position","position","layers","currentFilter","onToggleLayer","onDeleteFeature","_ref$actionIcons","actionIcons","children","onClose","_useState","_useState2","_slicedToArray","setCopied","_ref2","_ref2$layerId","layerId","intl","_useFloating","open","onOpenChange","v","refs","context","dismiss","_useInteractions","getFloatingProps","copyGeometry","geometry","JSON","stringify","isFilterLayerDisabled","createElement","_extends","ref","setFloating","style","top","concat","y","left","x","label","formatMessage","id","defaultMessage","Icon","isDisabled","tooltipText","length","map","index","key","config","color","dataId","isSelection","isActive","includes","onClick","displayName","FeatureActionPanelFactory"],"sources":["../../../src/editor/feature-action-panel.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useState, ComponentType} from 'react';\nimport {useIntl} from 'react-intl';\nimport copy from 'copy-to-clipboard';\nimport {useDismiss, useFloating, useInteractions} from '@floating-ui/react';\nimport classnames from 'classnames';\nimport styled from 'styled-components';\n\nimport {Layer} from '@kepler.gl/layers';\nimport {Filter} from '@kepler.gl/types';\nimport {Feature} from '@deck.gl-community/editable-layers';\nimport {Datasets} from '@kepler.gl/table';\nimport {canApplyFeatureFilter} from '@kepler.gl/utils';\n\nimport ActionPanel, {ActionPanelItem} from '../common/action-panel';\nimport {Trash, Layers, Copy, Checkmark} from '../common/icons';\n\nconst LAYOVER_OFFSET = 4;\n\nconst StyledActionsLayer = styled.div`\n  position: absolute;\n  .layer-panel-item-disabled {\n    color: ${props => props.theme.textColor};\n  }\n`;\nconst defaultActionIcons = {\n  remove: Trash,\n  layer: Layers,\n  copy: Copy,\n  copied: Checkmark\n};\nPureFeatureActionPanelFactory.deps = [];\n\nexport interface FeatureActionPanelProps {\n  className?: string;\n  datasets: Datasets;\n  selectedFeature: Feature | null;\n  position: {\n    x: number;\n    y: number;\n  } | null;\n  layers: Layer[];\n  currentFilter?: Filter;\n  onToggleLayer: (layer: Layer) => void;\n  onDeleteFeature: () => void;\n  onClose?: () => void;\n  children?: React.ReactNode;\n  actionIcons?: {\n    [id: string]: React.ElementType;\n  };\n}\n\nexport function PureFeatureActionPanelFactory(): React.FC<FeatureActionPanelProps> {\n  const FeatureActionPanel = ({\n    className,\n    datasets,\n    selectedFeature,\n    position = null,\n    layers,\n    currentFilter,\n    onToggleLayer,\n    onDeleteFeature,\n    actionIcons = defaultActionIcons,\n    children,\n    onClose\n  }: FeatureActionPanelProps) => {\n    const [copied, setCopied] = useState(false);\n    const {layerId = []} = currentFilter || {};\n    const intl = useIntl();\n\n    const {refs, context} = useFloating({\n      open: true,\n      onOpenChange: v => {\n        if (!v && onClose) {\n          onClose();\n        }\n      }\n    });\n    const dismiss = useDismiss(context);\n\n    const {getFloatingProps} = useInteractions([dismiss]);\n\n    const copyGeometry = useCallback(() => {\n      if (selectedFeature?.geometry) copy(JSON.stringify(selectedFeature.geometry));\n      setCopied(true);\n    }, [selectedFeature?.geometry]);\n\n    if (!position) {\n      return null;\n    }\n\n    const isFilterLayerDisabled = !canApplyFeatureFilter(selectedFeature as any);\n    return (\n      <StyledActionsLayer\n        ref={refs.setFloating}\n        {...getFloatingProps()}\n        className={classnames('feature-action-panel', className)}\n        style={{\n          top: `${position.y + LAYOVER_OFFSET}px`,\n          left: `${position.x + LAYOVER_OFFSET}px`\n        }}\n      >\n        <ActionPanel>\n          <ActionPanelItem\n            className=\"editor-layers-list\"\n            label={intl.formatMessage({id: 'editor.filterLayer', defaultMessage: 'Filter layers'})}\n            Icon={actionIcons.layer}\n            isDisabled={isFilterLayerDisabled}\n            tooltipText={\n              isFilterLayerDisabled ? intl.formatMessage({id: 'editor.filterLayerDisabled'}) : null\n            }\n          >\n            {layers.length ? (\n              layers.map((layer, index) => (\n                <ActionPanelItem\n                  key={index}\n                  label={layer.config.label}\n                  // @ts-ignore\n                  color={datasets[layer.config.dataId].color}\n                  isSelection={true}\n                  isActive={layerId.includes(layer.id)}\n                  onClick={() => onToggleLayer(layer)}\n                  className=\"layer-panel-item\"\n                />\n              ))\n            ) : (\n              <ActionPanelItem\n                key={'no-layers'}\n                label={intl.formatMessage({\n                  id: 'editor.noLayersToFilter',\n                  defaultMessage: 'No layers to filter'\n                })}\n                isSelection={false}\n                isActive={false}\n                className=\"layer-panel-item-disabled\"\n              />\n            )}\n          </ActionPanelItem>\n          <ActionPanelItem\n            label={intl.formatMessage({id: 'editor.copyGeometry', defaultMessage: 'Copy Geometry'})}\n            className=\"delete-panel-item\"\n            Icon={copied ? actionIcons.copied : actionIcons.copy}\n            onClick={copyGeometry}\n          />\n          {children}\n          <ActionPanelItem\n            label={intl.formatMessage({id: 'tooltip.delete', defaultMessage: 'Delete'})}\n            className=\"delete-panel-item\"\n            Icon={actionIcons.remove}\n            onClick={onDeleteFeature}\n          />\n        </ActionPanel>\n      </StyledActionsLayer>\n    );\n  };\n\n  FeatureActionPanel.displayName = 'FeatureActionPanel';\n\n  return FeatureActionPanel;\n}\n\nFeatureActionPanelFactory.deps = PureFeatureActionPanelFactory.deps;\n\nexport default function FeatureActionPanelFactory(): ComponentType<FeatureActionPanelProps> {\n  return PureFeatureActionPanelFactory();\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/effects/compact-color-picker.js

@@ -0,0 +1,103 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import styled from 'styled-components';
+import { rgbToHex } from '@kepler.gl/utils';
+import { Button } from '../common/styled-components';
+import Portaled from '../common/portaled';
+import SingleColorPalette from '../side-panel/layer-panel/single-color-palette';
+export var StyledPanelDropdown = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  ", "\n  background-color: ", ";\n  box-shadow: ", ";\n  border-radius: ", ";\n  overflow-y: auto;\n  max-height: 500px;\n  position: relative;\n  z-index: 999;\n  width: 220px;\n"])), function (props) {
+  return props.theme.panelDropdownScrollBar;
+}, function (props) {
+  return props.theme.panelBackground;
+}, function (props) {
+  return props.theme.panelBoxShadow;
+}, function (props) {
+  return props.theme.panelBorderRadius;
+});
+var StyledConfigSection = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n"])));
+var SectionTitle = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  font-size: ", ";\n  color: ", ";\n  margin-bottom: 8px;\n"])), function (props) {
+  return props.theme.inputFontSize;
+}, function (props) {
+  return props.theme.effectPanelTextSecondary2;
+});
+var StyledDropdownButtonWrapper = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  align-self: flex-start;\n  .button {\n    color: ", ";\n    display: flex;\n    gap: 5px;\n    border: none;\n    transition: background 0.2s;\n    background-color: ", ";\n    padding: 8px 5px 8px 10px;\n    &:active {\n      color: ", ";\n      background-color: ", ";\n    }\n    &:hover {\n      color: ", ";\n      background-color: ", ";\n    }\n    & > svg {\n      margin-right: 0;\n    }\n  }\n"])), function (props) {
+  return props.theme.effectPanelTextSecondary2;
+}, function (props) {
+  return props.theme.inputBgd;
+}, function (props) {
+  return props.theme.effectPanelTextMain;
+}, function (props) {
+  return props.theme.inputBgdHover;
+}, function (props) {
+  return props.theme.effectPanelTextMain;
+}, function (props) {
+  return props.theme.inputBgdHover;
+});
+var DEFAULT_OFFSET = {
+  top: 0,
+  left: 0
+};
+var SingleColorPickerDropdown = function SingleColorPickerDropdown(_ref) {
+  var isOpened = _ref.isOpened,
+    onClose = _ref.onClose,
+    selectedColor = _ref.selectedColor,
+    onSelectColor = _ref.onSelectColor,
+    _ref$offset = _ref.offset,
+    offset = _ref$offset === void 0 ? DEFAULT_OFFSET : _ref$offset;
+  var onSelectColorCb = useCallback(function (v) {
+    onSelectColor(v);
+  }, [onSelectColor]);
+  return /*#__PURE__*/React.createElement(Portaled, {
+    top: offset.top,
+    left: offset.left,
+    isOpened: isOpened,
+    onClose: onClose
+  }, /*#__PURE__*/React.createElement(StyledPanelDropdown, null, /*#__PURE__*/React.createElement(SingleColorPalette, {
+    selectedColor: selectedColor,
+    onSelectColor: onSelectColorCb
+  })));
+};
+var CompactColorPicker = function CompactColorPicker(_ref2) {
+  var color = _ref2.color,
+    onSetColor = _ref2.onSetColor,
+    Icon = _ref2.Icon,
+    label = _ref2.label;
+  var _React$useState = React.useState(false),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    isColorPickerOpened = _React$useState2[0],
+    setIsColorPickerOpened = _React$useState2[1];
+  var hexColor = useMemo(function () {
+    return rgbToHex(color);
+  }, [color]);
+  var colorBlockStyle = useMemo(function () {
+    return {
+      width: 16,
+      height: 16,
+      backgroundColor: hexColor,
+      borderRadius: 2
+    };
+  }, [hexColor]);
+  var toggleDropdown = useCallback(function () {
+    setIsColorPickerOpened(!isColorPickerOpened);
+  }, [isColorPickerOpened, setIsColorPickerOpened]);
+  var closeDropdown = useCallback(function () {
+    setIsColorPickerOpened(false);
+  }, [setIsColorPickerOpened]);
+  return /*#__PURE__*/React.createElement(StyledConfigSection, null, /*#__PURE__*/React.createElement(SectionTitle, null, label), /*#__PURE__*/React.createElement(StyledDropdownButtonWrapper, null, /*#__PURE__*/React.createElement(Button, {
+    onClick: toggleDropdown
+  }, /*#__PURE__*/React.createElement("div", {
+    style: colorBlockStyle
+  }), /*#__PURE__*/React.createElement(Icon, null))), /*#__PURE__*/React.createElement(SingleColorPickerDropdown, {
+    isOpened: isColorPickerOpened,
+    onClose: closeDropdown,
+    selectedColor: hexColor,
+    onSelectColor: onSetColor
+  }));
+};
+export default CompactColorPicker;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","styled","rgbToHex","Button","Portaled","SingleColorPalette","StyledPanelDropdown","div","_templateObject","_taggedTemplateLiteral","props","theme","panelDropdownScrollBar","panelBackground","panelBoxShadow","panelBorderRadius","StyledConfigSection","_templateObject2","SectionTitle","_templateObject3","inputFontSize","effectPanelTextSecondary2","StyledDropdownButtonWrapper","_templateObject4","inputBgd","effectPanelTextMain","inputBgdHover","DEFAULT_OFFSET","top","left","SingleColorPickerDropdown","_ref","isOpened","onClose","selectedColor","onSelectColor","_ref$offset","offset","onSelectColorCb","v","createElement","CompactColorPicker","_ref2","color","onSetColor","Icon","label","_React$useState","useState","_React$useState2","_slicedToArray","isColorPickerOpened","setIsColorPickerOpened","hexColor","colorBlockStyle","width","height","backgroundColor","borderRadius","toggleDropdown","closeDropdown","onClick","style"],"sources":["../../../src/effects/compact-color-picker.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo} from 'react';\nimport styled from 'styled-components';\n\nimport {rgbToHex} from '@kepler.gl/utils';\n\nimport {Button} from '../common/styled-components';\nimport Portaled from '../common/portaled';\nimport SingleColorPalette from '../side-panel/layer-panel/single-color-palette';\n\nexport type SingleColorPickerProps = {\n  color: [number, number, number];\n  onSetColor: (value: [number, number, number]) => void;\n  label: string;\n  Icon: React.ElementType;\n};\n\nexport const StyledPanelDropdown = styled.div`\n  ${props => props.theme.panelDropdownScrollBar}\n  background-color: ${props => props.theme.panelBackground};\n  box-shadow: ${props => props.theme.panelBoxShadow};\n  border-radius: ${props => props.theme.panelBorderRadius};\n  overflow-y: auto;\n  max-height: 500px;\n  position: relative;\n  z-index: 999;\n  width: 220px;\n`;\n\nconst StyledConfigSection = styled.div`\n  display: flex;\n  flex-direction: column;\n`;\n\nconst SectionTitle = styled.div`\n  font-size: ${props => props.theme.inputFontSize};\n  color: ${props => props.theme.effectPanelTextSecondary2};\n  margin-bottom: 8px;\n`;\n\nconst StyledDropdownButtonWrapper = styled.div`\n  align-self: flex-start;\n  .button {\n    color: ${props => props.theme.effectPanelTextSecondary2};\n    display: flex;\n    gap: 5px;\n    border: none;\n    transition: background 0.2s;\n    background-color: ${props => props.theme.inputBgd};\n    padding: 8px 5px 8px 10px;\n    &:active {\n      color: ${props => props.theme.effectPanelTextMain};\n      background-color: ${props => props.theme.inputBgdHover};\n    }\n    &:hover {\n      color: ${props => props.theme.effectPanelTextMain};\n      background-color: ${props => props.theme.inputBgdHover};\n    }\n    & > svg {\n      margin-right: 0;\n    }\n  }\n`;\n\nconst DEFAULT_OFFSET = {\n  top: 0,\n  left: 0\n};\n\nconst SingleColorPickerDropdown = ({\n  isOpened,\n  onClose,\n  selectedColor,\n  onSelectColor,\n  offset = DEFAULT_OFFSET\n}) => {\n  const onSelectColorCb = useCallback(\n    v => {\n      onSelectColor(v);\n    },\n    [onSelectColor]\n  );\n  return (\n    <Portaled top={offset.top} left={offset.left} isOpened={isOpened} onClose={onClose}>\n      <StyledPanelDropdown>\n        <SingleColorPalette selectedColor={selectedColor} onSelectColor={onSelectColorCb} />\n      </StyledPanelDropdown>\n    </Portaled>\n  );\n};\n\nconst CompactColorPicker: React.FC<SingleColorPickerProps> = ({\n  color,\n  onSetColor,\n  Icon,\n  label\n}: SingleColorPickerProps) => {\n  const [isColorPickerOpened, setIsColorPickerOpened] = React.useState(false);\n\n  const hexColor = useMemo(() => {\n    return rgbToHex(color);\n  }, [color]);\n\n  const colorBlockStyle = useMemo(\n    () => ({\n      width: 16,\n      height: 16,\n      backgroundColor: hexColor,\n      borderRadius: 2\n    }),\n    [hexColor]\n  );\n\n  const toggleDropdown = useCallback(() => {\n    setIsColorPickerOpened(!isColorPickerOpened);\n  }, [isColorPickerOpened, setIsColorPickerOpened]);\n\n  const closeDropdown = useCallback(() => {\n    setIsColorPickerOpened(false);\n  }, [setIsColorPickerOpened]);\n\n  return (\n    <StyledConfigSection>\n      <SectionTitle>{label}</SectionTitle>\n      <StyledDropdownButtonWrapper>\n        <Button onClick={toggleDropdown}>\n          <div style={colorBlockStyle} />\n          <Icon />\n        </Button>\n      </StyledDropdownButtonWrapper>\n      <SingleColorPickerDropdown\n        isOpened={isColorPickerOpened}\n        onClose={closeDropdown}\n        selectedColor={hexColor}\n        onSelectColor={onSetColor}\n      />\n    </StyledConfigSection>\n  );\n};\n\nexport default CompactColorPicker;\n"],"mappings":"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","ignoreList":[]}