@kepler.gl/components 3.0.0-alpha.0

package/dist/editor/editor.js

@@ -0,0 +1,279 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = EditorFactory;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reactMapGlDraw = require("react-map-gl-draw");
+
+var _window = _interopRequireDefault(require("global/window"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _lodash = _interopRequireDefault(require("lodash.get"));
+
+var _reselect = require("reselect");
+
+var _featureActionPanel = _interopRequireDefault(require("./feature-action-panel"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _featureStyles = require("./feature-styles");
+
+var _handleStyle = require("./handle-style");
+
+var _templateObject;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var StyledWrapper = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: ", ";\n  position: relative;\n"])), function (props) {
+  return props.editor.mode === _constants.EDITOR_MODES.EDIT ? 'pointer' : 'crosshair';
+});
+
+var editorLayerFilter = function editorLayerFilter(layer) {
+  return _constants.EDITOR_AVAILABLE_LAYERS.includes(layer.type);
+};
+
+EditorFactory.deps = [_featureActionPanel["default"]];
+
+function EditorFactory(FeatureActionPanel) {
+  var EditorUnmemoized = /*#__PURE__*/function (_Component) {
+    (0, _inherits2["default"])(EditorUnmemoized, _Component);
+
+    var _super = _createSuper(EditorUnmemoized);
+
+    function EditorUnmemoized() {
+      var _this;
+
+      (0, _classCallCheck2["default"])(this, EditorUnmemoized);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _super.call.apply(_super, [this].concat(args));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "state", {
+        showActions: false,
+        lastPosition: null
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layerSelector", function (props) {
+        return props.layers;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "layersToRenderSelector", function (props) {
+        return props.layersToRender;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "filterSelector", function (props) {
+        return props.filters;
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "selectedFeatureIdSelector", function (props) {
+        return (0, _lodash["default"])(props, ['editor', 'selectedFeature', 'id']);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "editorFeatureSelector", function (props) {
+        return (0, _lodash["default"])(props, ['editor', 'features']);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "currentFilterSelector", (0, _reselect.createSelector)(_this.filterSelector, _this.selectedFeatureIdSelector, function (filters, selectedFeatureId) {
+        return filters.find(function (f) {
+          return f.value && f.value.id === selectedFeatureId;
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "availableLayersSeletor", (0, _reselect.createSelector)(_this.layerSelector, _this.layersToRenderSelector, function (layers, layersToRender) {
+        return layers.filter(editorLayerFilter).filter(function (layer) {
+          return layersToRender[layer.id];
+        });
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "allFeaturesSelector", (0, _reselect.createSelector)(_this.filterSelector, _this.editorFeatureSelector, function (filters, editorFeatures) {
+        return filters.filter(function (f) {
+          return f.type === _constants.FILTER_TYPES.polygon;
+        }).map(function (f) {
+          return f.value;
+        }).concat(editorFeatures);
+      }));
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onKeyPressed", function (event) {
+        var isEnabled = _this.props.isEnabled;
+
+        if (!isEnabled) {
+          return;
+        }
+
+        switch (event.keyCode) {
+          case _constants.KeyEvent.DOM_VK_DELETE:
+          case _constants.KeyEvent.DOM_VK_BACK_SPACE:
+            _this._onDeleteSelectedFeature();
+
+            break;
+
+          case _constants.KeyEvent.DOM_VK_ESCAPE:
+            _this.props.onSelect(null);
+
+            break;
+
+          default:
+            break;
+        }
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onSelect", function (_ref) {
+        var selectedFeatureId = _ref.selectedFeatureId,
+            sourceEvent = _ref.sourceEvent;
+
+        var allFeatures = _this.allFeaturesSelector(_this.props);
+
+        _this.setState(_objectSpread({}, sourceEvent.rightButton ? {
+          showActions: true,
+          lastPosition: {
+            x: sourceEvent.changedPointers[0].offsetX,
+            y: sourceEvent.changedPointers[0].offsetY
+          }
+        } : null), function () {
+          _this.props.onSelect(allFeatures.find(function (f) {
+            return f.id === selectedFeatureId;
+          }));
+        });
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onDeleteSelectedFeature", function () {
+        if (_this.state.showActions) {
+          _this.setState({
+            showActions: false
+          });
+        }
+
+        var editor = _this.props.editor;
+        var _editor$selectedFeatu = editor.selectedFeature,
+            selectedFeature = _editor$selectedFeatu === void 0 ? {} : _editor$selectedFeatu;
+
+        _this.props.onDeleteFeature(selectedFeature);
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_closeFeatureAction", function () {
+        _this.setState({
+          showActions: false
+        });
+      });
+      (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "_onToggleLayer", function (layer) {
+        var selectedFeature = _this.props.editor.selectedFeature;
+
+        if (!selectedFeature) {
+          return;
+        }
+
+        _this.props.onTogglePolygonFilter(layer, selectedFeature);
+      });
+      return _this;
+    }
+
+    (0, _createClass2["default"])(EditorUnmemoized, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        _window["default"].addEventListener('keydown', this._onKeyPressed);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        _window["default"].removeEventListener('keydown', this._onKeyPressed);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            className = _this$props.className,
+            clickRadius = _this$props.clickRadius,
+            datasets = _this$props.datasets,
+            editor = _this$props.editor,
+            onUpdate = _this$props.onUpdate,
+            style = _this$props.style;
+        var _this$state = this.state,
+            lastPosition = _this$state.lastPosition,
+            showActions = _this$state.showActions;
+        var selectedFeatureId = (0, _lodash["default"])(editor, ['selectedFeature', 'id']);
+        var currentFilter = this.currentFilterSelector(this.props);
+        var availableLayers = this.availableLayersSeletor(this.props);
+        var allFeatures = this.allFeaturesSelector(this.props);
+        return /*#__PURE__*/_react["default"].createElement(StyledWrapper, {
+          editor: editor,
+          className: (0, _classnames["default"])('editor', className),
+          style: style
+        }, /*#__PURE__*/_react["default"].createElement(_reactMapGlDraw.Editor, {
+          clickRadius: clickRadius,
+          mode: editor.mode,
+          features: allFeatures,
+          selectedFeatureId: selectedFeatureId,
+          onSelect: this._onSelect,
+          onUpdate: onUpdate,
+          getEditHandleShape: _handleStyle.getEditHandleShape,
+          getFeatureStyle: _featureStyles.getStyle,
+          getEditHandleStyle: _handleStyle.getStyle
+        }), showActions && Boolean(selectedFeatureId) ? /*#__PURE__*/_react["default"].createElement(FeatureActionPanel, {
+          selectedFeature: (0, _lodash["default"])(editor, ['selectedFeature']),
+          datasets: datasets,
+          layers: availableLayers,
+          currentFilter: currentFilter,
+          onClose: this._closeFeatureAction,
+          onDeleteFeature: this._onDeleteSelectedFeature,
+          onToggleLayer: this._onToggleLayer,
+          position: lastPosition
+        }) : null);
+      }
+    }]);
+    return EditorUnmemoized;
+  }(_react.Component);
+
+  (0, _defineProperty2["default"])(EditorUnmemoized, "defaultProps", {
+    clickRadius: _featureStyles.DEFAULT_RADIUS
+  });
+  (0, _defineProperty2["default"])(EditorUnmemoized, "displayName", 'Editor');
+
+  var Editor = /*#__PURE__*/_react["default"].memo(EditorUnmemoized);
+
+  Editor.displayName = 'Editor';
+  return Editor;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/editor/editor.tsx"],"names":["StyledWrapper","styled","div","props","editor","mode","EDITOR_MODES","EDIT","editorLayerFilter","layer","EDITOR_AVAILABLE_LAYERS","includes","type","EditorFactory","deps","FeatureActionPanelFactory","FeatureActionPanel","EditorUnmemoized","showActions","lastPosition","layers","layersToRender","filters","filterSelector","selectedFeatureIdSelector","selectedFeatureId","find","f","value","id","layerSelector","layersToRenderSelector","filter","editorFeatureSelector","editorFeatures","FILTER_TYPES","polygon","map","concat","event","isEnabled","keyCode","KeyEvent","DOM_VK_DELETE","DOM_VK_BACK_SPACE","_onDeleteSelectedFeature","DOM_VK_ESCAPE","onSelect","sourceEvent","allFeatures","allFeaturesSelector","setState","rightButton","x","changedPointers","offsetX","y","offsetY","state","selectedFeature","onDeleteFeature","onTogglePolygonFilter","window","addEventListener","_onKeyPressed","removeEventListener","className","clickRadius","datasets","onUpdate","style","currentFilter","currentFilterSelector","availableLayers","availableLayersSeletor","_onSelect","getEditHandleShape","getFeatureStyle","getEditHandleStyle","Boolean","_closeFeatureAction","_onToggleLayer","Component","DEFAULT_RADIUS","Editor","React","memo","displayName"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {Component, CSSProperties, KeyboardEvent} from 'react';\nimport styled from 'styled-components';\nimport {Editor as Draw} from 'react-map-gl-draw';\nimport window from 'global/window';\nimport classnames from 'classnames';\nimport get from 'lodash.get';\nimport {createSelector} from 'reselect';\n\nimport FeatureActionPanelFactory, {FeatureActionPanelProps} from './feature-action-panel';\nimport {\n  EDITOR_AVAILABLE_LAYERS,\n  FILTER_TYPES,\n  EDITOR_MODES,\n  KeyEvent\n} from '@kepler.gl/constants';\nimport {Layer} from '@kepler.gl/layers';\n\nimport {DEFAULT_RADIUS, getStyle as getFeatureStyle} from './feature-styles';\nimport {getStyle as getEditHandleStyle, getEditHandleShape} from './handle-style';\nimport {Filter} from '@kepler.gl/types';\nimport {Feature} from '@nebula.gl/edit-modes';\nimport {MjolnirGestureEvent} from 'mjolnir.js';\nimport {Datasets} from '@kepler.gl/table';\n\nconst StyledWrapper = styled.div`\n  cursor: ${(props: {editor: {mode: string}}) =>\n    props.editor.mode === EDITOR_MODES.EDIT ? 'pointer' : 'crosshair'};\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};\n  layersToRender: Record<string, Layer>;\n  index: number;\n  className: string;\n  clickRadius: number;\n  style: CSSProperties;\n  isEnabled: boolean;\n  onSelect: (f: Feature | null) => void;\n  onUpdate: (f: Feature[]) => void;\n  onDeleteFeature: (f: Feature) => void;\n  onTogglePolygonFilter: (l: Layer, f: Feature) => void;\n}\n\nexport default function EditorFactory(\n  FeatureActionPanel: React.FC<FeatureActionPanelProps>\n): React.ComponentClass<EditorProps> {\n  class EditorUnmemoized extends Component<EditorProps> {\n    static defaultProps = {\n      clickRadius: DEFAULT_RADIUS\n    };\n\n    static displayName = 'Editor';\n\n    state = {\n      showActions: false,\n      lastPosition: null\n    };\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    layersToRenderSelector = (props: EditorProps) => props.layersToRender;\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    availableLayersSeletor = createSelector(\n      this.layerSelector,\n      this.layersToRenderSelector,\n      (layers, layersToRender) =>\n        layers.filter(editorLayerFilter).filter(layer => {\n          return layersToRender[layer.id];\n        })\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    _onKeyPressed = (event: KeyboardEvent) => {\n      const {isEnabled} = this.props;\n\n      if (!isEnabled) {\n        return;\n      }\n\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          this.props.onSelect(null);\n          break;\n        default:\n          break;\n      }\n    };\n\n    _onSelect = ({\n      selectedFeatureId,\n      sourceEvent\n    }: {\n      selectedFeatureId: string | number;\n      sourceEvent: MjolnirGestureEvent;\n    }) => {\n      const allFeatures = this.allFeaturesSelector(this.props);\n      this.setState(\n        {\n          ...(sourceEvent.rightButton\n            ? {\n                showActions: true,\n                lastPosition: {\n                  x: sourceEvent.changedPointers[0].offsetX,\n                  y: sourceEvent.changedPointers[0].offsetY\n                }\n              }\n            : null)\n        },\n        () => {\n          this.props.onSelect(allFeatures.find(f => f.id === selectedFeatureId));\n        }\n      );\n    };\n\n    _onDeleteSelectedFeature = () => {\n      if (this.state.showActions) {\n        this.setState({showActions: false});\n      }\n\n      const {editor} = this.props;\n      const {selectedFeature = {}} = editor;\n      this.props.onDeleteFeature(selectedFeature);\n    };\n\n    _closeFeatureAction = () => {\n      this.setState({showActions: false});\n    };\n\n    _onToggleLayer = (layer: Layer) => {\n      const {selectedFeature} = this.props.editor;\n      if (!selectedFeature) {\n        return;\n      }\n\n      this.props.onTogglePolygonFilter(layer, selectedFeature);\n    };\n\n    render() {\n      const {className, clickRadius, datasets, editor, onUpdate, style} = this.props;\n\n      const {lastPosition, showActions} = this.state;\n      const selectedFeatureId = get(editor, ['selectedFeature', 'id']);\n      const currentFilter = this.currentFilterSelector(this.props);\n      const availableLayers = this.availableLayersSeletor(this.props);\n      const allFeatures = this.allFeaturesSelector(this.props);\n\n      return (\n        <StyledWrapper editor={editor} className={classnames('editor', className)} style={style}>\n          <Draw\n            clickRadius={clickRadius}\n            mode={editor.mode}\n            features={allFeatures}\n            selectedFeatureId={selectedFeatureId}\n            onSelect={this._onSelect}\n            onUpdate={onUpdate}\n            getEditHandleShape={getEditHandleShape}\n            getFeatureStyle={getFeatureStyle}\n            getEditHandleStyle={getEditHandleStyle}\n          />\n          {showActions && Boolean(selectedFeatureId) ? (\n            <FeatureActionPanel\n              selectedFeature={get(editor, ['selectedFeature'])}\n              datasets={datasets}\n              layers={availableLayers}\n              currentFilter={currentFilter}\n              onClose={this._closeFeatureAction}\n              onDeleteFeature={this._onDeleteSelectedFeature}\n              onToggleLayer={this._onToggleLayer}\n              position={lastPosition}\n            />\n          ) : null}\n        </StyledWrapper>\n      );\n    }\n  }\n\n  const Editor = (React.memo(EditorUnmemoized) as unknown) as typeof EditorUnmemoized;\n  Editor.displayName = 'Editor';\n  return Editor;\n}\n"]}

package/dist/editor/feature-action-panel.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { Layer } from '@kepler.gl/layers';
+import { Filter } from '@kepler.gl/types';
+import { Feature } from '@nebula.gl/edit-modes';
+import { Datasets } from '@kepler.gl/table';
+export interface FeatureActionPanelProps {
+    className?: string;
+    datasets: Datasets;
+    selectedFeature: Feature | null;
+    position: {
+        x: number;
+        y: number;
+    } | null;
+    layers: Layer[];
+    currentFilter?: Filter;
+    onToggleLayer: (l: Layer) => void;
+    onDeleteFeature: () => void;
+    onClose: () => void;
+}
+export declare function PureFeatureActionPanelFactory(): React.FC<FeatureActionPanelProps>;
+export declare namespace PureFeatureActionPanelFactory {
+    var deps: any[];
+}
+declare function FeatureActionPanelFactory(): import("react-onclickoutside").WrapperClass<FeatureActionPanelProps & {
+    children?: React.ReactNode;
+}, React.FC<FeatureActionPanelProps>>;
+declare namespace FeatureActionPanelFactory {
+    var deps: any[];
+}
+export default FeatureActionPanelFactory;

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

@@ -0,0 +1,169 @@
+// Copyright (c) 2022 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PureFeatureActionPanelFactory = PureFeatureActionPanelFactory;
+exports["default"] = FeatureActionPanelFactory;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactIntl = require("react-intl");
+
+var _actionPanel = _interopRequireWildcard(require("../common/action-panel"));
+
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+
+var _reactOnclickoutside = _interopRequireDefault(require("react-onclickoutside"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _icons = require("../common/icons");
+
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+
+var _templateObject;
+
+var LAYOVER_OFFSET = 4;
+
+var StyledActionsLayer = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  position: absolute;\n"])));
+
+PureFeatureActionPanelFactory.deps = [];
+
+function PureFeatureActionPanelFactory() {
+  var FeatureActionPanel = function FeatureActionPanel(_ref) {
+    var className = _ref.className,
+        datasets = _ref.datasets,
+        selectedFeature = _ref.selectedFeature,
+        position = _ref.position,
+        layers = _ref.layers,
+        currentFilter = _ref.currentFilter,
+        onToggleLayer = _ref.onToggleLayer,
+        onDeleteFeature = _ref.onDeleteFeature;
+
+    var _useState = (0, _react.useState)(false),
+        _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+        copied = _useState2[0],
+        setCopied = _useState2[1];
+
+    var _ref2 = currentFilter || {},
+        _ref2$layerId = _ref2.layerId,
+        layerId = _ref2$layerId === void 0 ? [] : _ref2$layerId;
+
+    var intl = (0, _reactIntl.useIntl)();
+    var copyGeometry = (0, _react.useCallback)(function () {
+      if (selectedFeature !== null && selectedFeature !== void 0 && selectedFeature.geometry) (0, _copyToClipboard["default"])(JSON.stringify(selectedFeature.geometry));
+      setCopied(true);
+    }, [selectedFeature === null || selectedFeature === void 0 ? void 0 : selectedFeature.geometry]);
+
+    if (!position) {
+      return null;
+    }
+
+    return /*#__PURE__*/_react["default"].createElement(StyledActionsLayer, {
+      className: (0, _classnames["default"])('feature-action-panel', className),
+      style: {
+        top: "".concat(position.y + LAYOVER_OFFSET, "px"),
+        left: "".concat(position.x + LAYOVER_OFFSET, "px")
+      }
+    }, /*#__PURE__*/_react["default"].createElement(_actionPanel["default"], null, /*#__PURE__*/_react["default"].createElement(_actionPanel.ActionPanelItem, {
+      className: "editor-layers-list",
+      label: intl.formatMessage({
+        id: 'editor.filterLayer',
+        defaultMessage: 'Filter layers'
+      }),
+      Icon: _icons.Layers
+    }, layers.map(function (layer, index) {
+      return /*#__PURE__*/_react["default"].createElement(_actionPanel.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["default"].createElement(_actionPanel.ActionPanelItem, {
+      label: intl.formatMessage({
+        id: 'editor.copyGeometry',
+        defaultMessage: 'Copy Geometry'
+      }),
+      className: "delete-panel-item",
+      Icon: copied ? _icons.Checkmark : _icons.Copy,
+      onClick: copyGeometry
+    }), /*#__PURE__*/_react["default"].createElement(_actionPanel.ActionPanelItem, {
+      label: intl.formatMessage({
+        id: 'tooltip.delete',
+        defaultMessage: 'Delete'
+      }),
+      className: "delete-panel-item",
+      Icon: _icons.Trash,
+      onClick: onDeleteFeature
+    })));
+  };
+
+  FeatureActionPanel.displayName = 'FeatureActionPanel';
+  FeatureActionPanel.defaultProps = {
+    position: null
+  };
+  return FeatureActionPanel;
+}
+
+FeatureActionPanelFactory.deps = PureFeatureActionPanelFactory.deps;
+
+function FeatureActionPanelFactory() {
+  var PureFeatureActionPanel = PureFeatureActionPanelFactory();
+
+  var ClickOutsideFeatureActionPanel = function ClickOutsideFeatureActionPanel(props) {
+    // @ts-ignore
+    ClickOutsideFeatureActionPanel.handleClickOutside = function (e) {
+      var _props$onClose;
+
+      e.preventDefault();
+      e.stopPropagation();
+      (_props$onClose = props.onClose) === null || _props$onClose === void 0 ? void 0 : _props$onClose.call(props);
+    };
+
+    return /*#__PURE__*/_react["default"].createElement(PureFeatureActionPanel, props);
+  };
+
+  var clickOutsideConfig = {
+    // @ts-ignore
+    handleClickOutside: function handleClickOutside() {
+      return ClickOutsideFeatureActionPanel.handleClickOutside;
+    }
+  };
+  return (0, _reactOnclickoutside["default"])(ClickOutsideFeatureActionPanel, clickOutsideConfig);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/editor/feature-action-panel.tsx"],"names":["LAYOVER_OFFSET","StyledActionsLayer","styled","div","PureFeatureActionPanelFactory","deps","FeatureActionPanel","className","datasets","selectedFeature","position","layers","currentFilter","onToggleLayer","onDeleteFeature","copied","setCopied","layerId","intl","copyGeometry","geometry","JSON","stringify","top","y","left","x","formatMessage","id","defaultMessage","Layers","map","layer","index","config","label","dataId","color","includes","Checkmark","Copy","Trash","displayName","defaultProps","FeatureActionPanelFactory","PureFeatureActionPanel","ClickOutsideFeatureActionPanel","props","handleClickOutside","e","preventDefault","stopPropagation","onClose","clickOutsideConfig"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {useCallback, useState} from 'react';\nimport {useIntl} from 'react-intl';\n\nimport ActionPanel, {ActionPanelItem} from '../common/action-panel';\nimport styled from 'styled-components';\nimport onClickOutside from 'react-onclickoutside';\nimport classnames from 'classnames';\nimport {Trash, Layers, Copy, Checkmark} from '../common/icons';\nimport copy from 'copy-to-clipboard';\nimport {Layer} from '@kepler.gl/layers';\nimport {Filter} from '@kepler.gl/types';\nimport {Feature} from '@nebula.gl/edit-modes';\nimport {Datasets} from '@kepler.gl/table';\n\nconst LAYOVER_OFFSET = 4;\n\nconst StyledActionsLayer = styled.div`\n  position: absolute;\n`;\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: (l: Layer) => void;\n  onDeleteFeature: () => void;\n  onClose: () => void;\n}\n\nexport function PureFeatureActionPanelFactory(): React.FC<FeatureActionPanelProps> {\n  const FeatureActionPanel = ({\n    className,\n    datasets,\n    selectedFeature,\n    position,\n    layers,\n    currentFilter,\n    onToggleLayer,\n    onDeleteFeature\n  }: FeatureActionPanelProps) => {\n    const [copied, setCopied] = useState(false);\n    const {layerId = []} = currentFilter || {};\n    const intl = useIntl();\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    return (\n      <StyledActionsLayer\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={Layers}\n          >\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          </ActionPanelItem>\n          <ActionPanelItem\n            label={intl.formatMessage({id: 'editor.copyGeometry', defaultMessage: 'Copy Geometry'})}\n            className=\"delete-panel-item\"\n            Icon={copied ? Checkmark : Copy}\n            onClick={copyGeometry}\n          />\n\n          <ActionPanelItem\n            label={intl.formatMessage({id: 'tooltip.delete', defaultMessage: 'Delete'})}\n            className=\"delete-panel-item\"\n            Icon={Trash}\n            onClick={onDeleteFeature}\n          />\n        </ActionPanel>\n      </StyledActionsLayer>\n    );\n  };\n\n  FeatureActionPanel.displayName = 'FeatureActionPanel';\n  FeatureActionPanel.defaultProps = {\n    position: null\n  };\n\n  return FeatureActionPanel;\n}\n\nFeatureActionPanelFactory.deps = PureFeatureActionPanelFactory.deps;\n\nexport default function FeatureActionPanelFactory() {\n  const PureFeatureActionPanel = PureFeatureActionPanelFactory();\n\n  const ClickOutsideFeatureActionPanel: React.FC<FeatureActionPanelProps> = props => {\n    // @ts-ignore\n    ClickOutsideFeatureActionPanel.handleClickOutside = (e: Event) => {\n      e.preventDefault();\n      e.stopPropagation();\n      props.onClose?.();\n    };\n    return <PureFeatureActionPanel {...props} />;\n  };\n\n  const clickOutsideConfig = {\n    // @ts-ignore\n    handleClickOutside: () => ClickOutsideFeatureActionPanel.handleClickOutside\n  };\n\n  return onClickOutside(ClickOutsideFeatureActionPanel, clickOutsideConfig);\n}\n"]}

package/dist/editor/feature-styles.d.ts

@@ -0,0 +1,37 @@
+export declare const DEFAULT_RADIUS = 5;
+export declare const DEFAULT_STATE_STYLE_STROKE: string;
+export declare const STATE_STYLES_STROKE: {
+    [x: number]: string;
+};
+export declare const DEFAULT_STATE_STYLE_FILL = "#000";
+export declare const STATE_STYLES_FILL: {
+    [x: number]: string;
+};
+export declare const DEFAULT_STATE_STYLE_OPACITY = 0.1;
+export declare const STATE_STYLES_STROKE_WIDTH = 2;
+export declare const DEFAULT_STROKE_DASH_ARRAY = "4,2";
+export declare const RENDER_TYPE_STYLES: {
+    [x: number]: (() => {
+        r: number;
+    }) | (() => {
+        fill: string;
+    });
+};
+export declare function noOp(): void;
+export declare function getStyle({ feature, state }: {
+    feature: any;
+    state: any;
+}): {
+    r: number;
+    strokeDasharray?: string | undefined;
+    stroke: string;
+    strokeWidth: number;
+    fill: string;
+    fillOpacity: number;
+} | {
+    fill: string;
+    strokeDasharray?: string | undefined;
+    stroke: string;
+    strokeWidth: number;
+    fillOpacity: number;
+};