@carto/kepler.gl 0.0.88 → 0.0.89

package/dist/vendor/react-map-gl-draw/editor.js

@@ -0,0 +1,1122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactMapGl = require("react-map-gl");
+var _uuid = require("uuid");
+var _feature2 = _interopRequireDefault(require("./feature"));
+var _style = require("./style");
+var _constants = require("./constants");
+var _utils = require("./utils");
+var _excluded = ["radius"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+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) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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; })(); } // Vendored from react-map-gl-draw@0.14.8 (MIT, Copyright (c) 2018 Uber Technologies, Inc.), see ./LICENSE
+/* eslint-disable complexity, max-statements */
+var defaultProps = {
+  mode: _constants.MODES.READ_ONLY,
+  clickRadius: 0,
+  getEditHandleStyle: _style.getEditHandleStyle,
+  getFeatureStyle: _style.getFeatureStyle,
+  getFeatureShape: 'circle',
+  getEditHandleShape: 'circle',
+  onSelect: function onSelect() {}
+};
+var UNCOMMITTED_ID = 'uncommitted';
+var Editor = exports["default"] = /*#__PURE__*/function (_PureComponent) {
+  function Editor(props) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, Editor);
+    _this = _callSuper(this, Editor, [props]);
+    (0, _defineProperty2["default"])(_this, "_containerRef", void 0);
+    (0, _defineProperty2["default"])(_this, "_events", void 0);
+    (0, _defineProperty2["default"])(_this, "_context", void 0);
+    /* FEATURE OPERATIONS */
+    (0, _defineProperty2["default"])(_this, "_update", function (features) {
+      if (features) {
+        _this.props.onUpdate(features.map(function (f) {
+          return f.toFeature();
+        }));
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_updateRectangle", function (feature, options) {
+      var vertexIndex = options.vertexIndex,
+        lngLat = options.lngLat;
+      /*
+       *   p0.x, p0.y   ----------  diagonal.x, p0.y
+       *       |                             |
+       *       |                             |
+       *   p0.x, diagonal.y ----- diagonal.x, diagonal.y
+       */
+      var diagonal = vertexIndex;
+      var p0 = feature.points[(diagonal + 2) % 4];
+      feature.replacePoint(diagonal, [lngLat[0], lngLat[1]]);
+      feature.replacePoint((diagonal + 1) % 4, [lngLat[0], p0[1]]);
+      feature.replacePoint((diagonal + 3) % 4, [p0[0], lngLat[1]]);
+      _this._update(_this.state.features);
+    });
+    (0, _defineProperty2["default"])(_this, "_updateFeature", function (feature, mode, options) {
+      switch (mode) {
+        case 'vertex':
+          if (feature.renderType === _constants.RENDER_TYPE.RECTANGLE) {
+            _this._updateRectangle(feature, options);
+          } else {
+            feature.replacePoint(options.vertexIndex, [options.lngLat[0], options.lngLat[1]]);
+            _this._update(_this.state.features);
+          }
+          break;
+        case 'feature':
+          var dx = options.dx,
+            dy = options.dy;
+          feature.points = feature.points.map(function (lngLat) {
+            var pixels = _this._project(lngLat);
+            if (pixels) {
+              pixels[0] += dx;
+              pixels[1] += dy;
+              return _this._unproject(pixels);
+            }
+            return null;
+          }).filter(Boolean);
+          _this._update(_this.state.features);
+          break;
+        case 'Rectangle':
+          _this._updateRectangle(feature, options);
+          break;
+        default:
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_addPoint", function (x, y, feature) {
+      var isNew = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      feature = feature || _this._getSelectedFeature();
+      if (!feature) {
+        return;
+      }
+      var lngLat = _this._unproject([x, y]);
+      if (!lngLat) {
+        return;
+      }
+      feature.addPoint([lngLat[0], lngLat[1]]);
+      var features = _this.state.features || [];
+      if (isNew) {
+        features.push(feature);
+      }
+      var validPath = feature.points && feature.points.length >= 2;
+      var _this$props = _this.props,
+        mode = _this$props.mode,
+        onSelect = _this$props.onSelect;
+      if (mode === _constants.MODES.DRAW_POINT || mode === _constants.MODES.DRAW_PATH && validPath) {
+        _this._update(features);
+        onSelect({
+          selectedFeatureId: feature && feature.id
+        });
+      } else {
+        _this.setState({
+          features: (0, _toConsumableArray2["default"])(features),
+          selectedFeatureId: feature && feature.id
+        });
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_clearCache", function () {
+      _this.setState({
+        selectedFeatureId: null,
+        uncommittedLngLat: null,
+        hoveredFeatureId: null,
+        hoveredLngLat: null,
+        hoveredVertexIndex: -1,
+        draggingVertexIndex: -1,
+        startDragPos: null,
+        isDragging: false,
+        didDrag: false
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "_closePath", function () {
+      var selectedFeature = _this._getSelectedFeature();
+      if (selectedFeature) {
+        selectedFeature.closePath();
+        _this._update(_this.state.features);
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_addFeature", function (mode, point) {
+      var type = _constants.MODE_TO_GEOJSON_TYPE[mode];
+      var renderType = _constants.MODE_TO_RENDER_TYPE[mode];
+      var feature = new _feature2["default"]({
+        id: (0, _uuid.v4)(),
+        type: type,
+        renderType: renderType
+      });
+      _this._addPoint(point.x, point.y, feature, true);
+      if (mode === _constants.MODES.DRAW_RECTANGLE) {
+        for (var i = 0; i < 3; i++) {
+          _this._addPoint(point.x, point.y, feature, false);
+        }
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onEvent", function (handler, evt, stopPropagation) {
+      var mode = _this.props.mode;
+      if (mode === _constants.MODES.READ_ONLY) {
+        return;
+      }
+      for (var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+        args[_key - 3] = arguments[_key];
+      }
+      handler.apply(void 0, [evt].concat(args));
+      if (stopPropagation) {
+        evt.stopImmediatePropagation();
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onMouseUp", function (evt) {
+      _this.setState({
+        isDragging: false,
+        didDrag: false
+      });
+      var draggingVertexIndex = _this.state.draggingVertexIndex;
+      if (Number(draggingVertexIndex) >= 0) {
+        _this.setState({
+          draggingVertexIndex: -1
+        });
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onMouseDown", function (evt) {
+      var _this$_getEventPositi = _this._getEventPosition(evt),
+        x = _this$_getEventPositi.x,
+        y = _this$_getEventPositi.y;
+      var attributes = (0, _utils.parseElemDataAttributes)(evt.target);
+
+      // click segment
+      if (attributes && attributes.type === _constants.ELEMENT_TYPE.VERTEX) {
+        var vertexIndex = attributes.vertexIndex;
+        _this.setState({
+          draggingVertexIndex: vertexIndex,
+          startDragPos: {
+            x: x,
+            y: y
+          },
+          isDragging: true
+        });
+
+        // click selected feature
+      } else if (_this._matchesFeature(attributes, _this._getSelectedFeature())) {
+        _this.setState({
+          startDragPos: {
+            x: x,
+            y: y
+          },
+          isDragging: true
+        });
+      }
+    });
+    /* eslint-disable max-depth */
+    (0, _defineProperty2["default"])(_this, "_onMouseMove", function (evt) {
+      var attributes = (0, _utils.parseElemDataAttributes)(evt.target) || {};
+      var vertexIndex = attributes.vertexIndex,
+        featureIndex = attributes.featureIndex,
+        type = attributes.type;
+      var _this$state = _this.state,
+        startDragPos = _this$state.startDragPos,
+        isDragging = _this$state.isDragging,
+        didDrag = _this$state.didDrag;
+      var mode = _this.props.mode;
+      var _this$_getEventPositi2 = _this._getEventPosition(evt),
+        x = _this$_getEventPositi2.x,
+        y = _this$_getEventPositi2.y;
+      var lngLat = _this._unproject([x, y]);
+      if (isDragging && !didDrag && startDragPos) {
+        var dx = x - startDragPos.x;
+        var dy = y - startDragPos.y;
+        if (dx * dx + dy * dy > 5) {
+          _this.setState({
+            didDrag: true
+          });
+        }
+      }
+      var selectedFeature = _this._getSelectedFeature();
+      var isDrawing = _constants.DRAWING_MODES.indexOf(mode) !== -1;
+      var isEditing = mode === _constants.MODES.EDIT_VERTEX;
+      if (selectedFeature) {
+        // dragging
+        if (didDrag && startDragPos) {
+          var draggingVertexIndex = Number(_this.state.draggingVertexIndex);
+          if (draggingVertexIndex >= 0) {
+            // dragging vertex
+            _this._updateFeature(selectedFeature, 'vertex', {
+              vertexIndex: draggingVertexIndex,
+              lngLat: lngLat
+            });
+          } else {
+            // dragging feature
+            var _dx = x - startDragPos.x;
+            var _dy = y - startDragPos.y;
+            _this.setState({
+              startDragPos: {
+                x: x,
+                y: y
+              }
+            });
+            _this._updateFeature(selectedFeature, 'feature', {
+              dx: _dx,
+              dy: _dy
+            });
+          }
+        } else if (mode === _constants.MODES.DRAW_RECTANGLE) {
+          // drawing rectangle
+          _this._updateFeature(selectedFeature, 'Rectangle', {
+            vertexIndex: 2,
+            lngLat: lngLat
+          });
+        } else if (isDrawing) {
+          // drawing other shapes
+          _this.setState({
+            uncommittedLngLat: lngLat
+          });
+        } else if (isEditing) {
+          if ((selectedFeature.renderType === _constants.RENDER_TYPE.LINE_STRING || selectedFeature.renderType === _constants.RENDER_TYPE.POLYGON) && type === _constants.ELEMENT_TYPE.SEGMENT) {
+            // segmentId is start vertexIndex
+            var uncommittedLngLat = null;
+            if (lngLat && typeof vertexIndex === 'number') {
+              uncommittedLngLat = _this._getClosestPositionOnSegment(vertexIndex, lngLat, selectedFeature);
+            }
+            _this.setState({
+              uncommittedLngLat: uncommittedLngLat
+            });
+          } else {
+            _this.setState({
+              uncommittedLngLat: null
+            });
+          }
+        }
+      }
+      var _this$state2 = _this.state,
+        features = _this$state2.features,
+        selectedFeatureId = _this$state2.selectedFeatureId;
+      if (selectedFeatureId && type === _constants.ELEMENT_TYPE.VERTEX && typeof featureIndex === 'number') {
+        var feature = features && features[featureIndex];
+        if (selectedFeatureId === (feature && feature.id)) {
+          _this.setState({
+            hoveredVertexIndex: vertexIndex
+          });
+        }
+      } else if (type !== _constants.ELEMENT_TYPE.VERTEX) {
+        _this.setState({
+          hoveredVertexIndex: null
+        });
+      }
+      if (type === _constants.ELEMENT_TYPE.FEATURE && typeof featureIndex === 'number') {
+        var _feature = features && features[featureIndex];
+        _this.setState({
+          hoveredFeatureId: _feature && _feature.id
+        });
+      } else {
+        _this.setState({
+          hoveredFeatureId: null
+        });
+      }
+    });
+    /* eslint-enable max-depth */
+    (0, _defineProperty2["default"])(_this, "_onClickFeature", function (evt, attributes) {
+      var featureIndex = attributes.featureIndex;
+      var features = _this.state.features;
+      var selectedFeature = features && typeof featureIndex === 'number' && features[featureIndex];
+      if (selectedFeature) {
+        _this.props.onSelect({
+          selectedFeatureId: selectedFeature.id,
+          sourceEvent: evt
+        });
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onClickVertex", function (evt, attributes) {
+      var mode = _this.props.mode;
+      var operation = attributes.operation;
+      if (operation === _constants.OPERATIONS.INTERSECT || operation === _constants.OPERATIONS.SET && mode === _constants.MODES.DRAW_RECTANGLE) {
+        _this._closePath();
+        _this._clearCache();
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onClickSegment", function (evt, attributes) {
+      var feature = _this._getSelectedFeature();
+      if (feature && (feature.renderType === _constants.RENDER_TYPE.POLYGON || feature.renderType === _constants.RENDER_TYPE.LINE_STRING) && attributes) {
+        var vertexIndex = attributes.vertexIndex;
+        var uncommittedLngLat = _this.state.uncommittedLngLat;
+        var lngLat = uncommittedLngLat;
+        if (!lngLat && typeof vertexIndex === 'number') {
+          var _this$_getEventPositi3 = _this._getEventPosition(evt),
+            x = _this$_getEventPositi3.x,
+            y = _this$_getEventPositi3.y;
+          lngLat = _this._unproject([x, y]);
+          lngLat = _this._getClosestPositionOnSegment(vertexIndex, lngLat, feature);
+        }
+        if (lngLat) {
+          var insertPosition = (vertexIndex + 1) % feature.points.length;
+          feature.insertPoint(lngLat, insertPosition);
+          _this._update(_this.state.features);
+        }
+        _this.setState({
+          uncommittedLngLat: null,
+          hoveredLngLat: null
+        });
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_onClick", function (evt) {
+      var mode = _this.props.mode;
+      var attributes = (0, _utils.parseElemDataAttributes)(evt.target);
+      if (attributes && attributes.type === _constants.ELEMENT_TYPE.VERTEX) {
+        _this._onClickVertex(evt, attributes);
+        return;
+      }
+      if (mode === _constants.MODES.EDIT_VERTEX && attributes && attributes.type === _constants.ELEMENT_TYPE.SEGMENT) {
+        _this._onClickSegment(evt, attributes);
+        return;
+      }
+      if ((mode === _constants.MODES.SELECT_FEATURE || mode === _constants.MODES.EDIT_VERTEX) && attributes && attributes.type === _constants.ELEMENT_TYPE.FEATURE) {
+        _this._onClickFeature(evt, attributes);
+        return;
+      }
+      var selectedFeature = _this._getSelectedFeature();
+      var _this$_getEventPositi4 = _this._getEventPosition(evt),
+        x = _this$_getEventPositi4.x,
+        y = _this$_getEventPositi4.y;
+      switch (mode) {
+        case _constants.MODES.EDIT_VERTEX:
+          if (selectedFeature) {
+            _this.props.onSelect({
+              selectedFeatureId: null,
+              sourceEvent: evt
+            });
+          }
+          break;
+        case _constants.MODES.DRAW_POINT:
+          _this._addFeature(mode, {
+            x: x,
+            y: y
+          });
+          break;
+        case _constants.MODES.DRAW_PATH:
+        case _constants.MODES.DRAW_POLYGON:
+          if (selectedFeature && selectedFeature.isClosed) {
+            // clicked outside
+            _this._clearCache();
+          } else if (selectedFeature) {
+            _this._addPoint(x, y, selectedFeature);
+          } else {
+            _this._addFeature(mode, {
+              x: x,
+              y: y
+            });
+          }
+          break;
+        case _constants.MODES.DRAW_RECTANGLE:
+          if (selectedFeature && selectedFeature.isClosed) {
+            // clicked outside
+            _this._clearCache();
+            _this.props.onSelect({
+              selectedFeatureId: null,
+              sourceEvent: evt
+            });
+          } else {
+            _this._addFeature(mode, {
+              x: x,
+              y: y
+            });
+          }
+          break;
+        default:
+      }
+    });
+    // don't forward pan events to the underlying map when:
+    // - the pan target is a vertex/line/the currently selected feature
+    // - the user is dragging something around
+    // - there is currently an uncommitted position
+    // (i.e. the user is creating a feature/vertex/line)
+    (0, _defineProperty2["default"])(_this, "_onPan", function (evt) {
+      var attributes = (0, _utils.parseElemDataAttributes)(evt.target);
+      var type = attributes && attributes.type;
+      if (type === _constants.ELEMENT_TYPE.VERTEX || type === _constants.ELEMENT_TYPE.SEGMENT || _this.state.isDragging || _this.state.uncommittedLngLat !== null) {
+        evt.stopImmediatePropagation();
+      }
+    });
+    /* HELPERS */
+    // lngLat to pixels
+    (0, _defineProperty2["default"])(_this, "_project", function (pt) {
+      return _this._context && _this._context.viewport && _this._context.viewport.project(pt);
+    });
+    // pixels to lngLat
+    (0, _defineProperty2["default"])(_this, "_unproject", function (pt) {
+      return _this._context && _this._context.viewport && _this._context.viewport.unproject(pt);
+    });
+    (0, _defineProperty2["default"])(_this, "_matchesFeature", function (attributes, feature) {
+      if (!attributes || attributes.type !== _constants.ELEMENT_TYPE.FEATURE || !feature) {
+        return false;
+      }
+      var featureIndex = attributes.featureIndex;
+      var features = _this.props.features;
+      var elemFeature = features && features[featureIndex];
+      return elemFeature && feature.id === elemFeature.id;
+    });
+    (0, _defineProperty2["default"])(_this, "_getClosestPositionOnSegment", function (vertexIndex, pointLngLat, feature) {
+      var points = feature && feature.points;
+      if (!points || !points.length) {
+        return null;
+      }
+
+      // segmentId is start vertexIndex
+      var startPos = points[vertexIndex];
+      var endPos = points[(vertexIndex + 1) % points.length];
+      return (0, _utils.findClosestPointOnLineSegment)(startPos, endPos, pointLngLat);
+    });
+    (0, _defineProperty2["default"])(_this, "_getEventPosition", function (evt) {
+      var _evt$offsetCenter = evt.offsetCenter,
+        x = _evt$offsetCenter.x,
+        y = _evt$offsetCenter.y;
+      return {
+        x: Number(x),
+        y: Number(y)
+      };
+    });
+    (0, _defineProperty2["default"])(_this, "_getSelectedFeature", function () {
+      var _this$state3 = _this.state,
+        features = _this$state3.features,
+        selectedFeatureId = _this$state3.selectedFeatureId;
+      return features && features.find(function (f) {
+        return f.id === selectedFeatureId;
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "_getEditHandleState", function (index, renderState) {
+      var mode = _this.props.mode;
+      var _this$state4 = _this.state,
+        draggingVertexIndex = _this$state4.draggingVertexIndex,
+        hoveredVertexIndex = _this$state4.hoveredVertexIndex;
+      var selectedFeature = _this._getSelectedFeature();
+      var isSelected = index === draggingVertexIndex || selectedFeature && selectedFeature.renderType === _constants.RENDER_TYPE.POINT;
+      var isClosing = mode === _constants.MODES.DRAW_POLYGON && hoveredVertexIndex === 0 && index === -1;
+      if (renderState) {
+        return renderState;
+      }
+      if (isClosing) {
+        return _constants.RENDER_STATE.CLOSING;
+      }
+      if (isSelected) {
+        return _constants.RENDER_STATE.SELECTED;
+      }
+      switch (index) {
+        case hoveredVertexIndex:
+          return _constants.RENDER_STATE.HOVERED;
+        case UNCOMMITTED_ID:
+          return _constants.RENDER_STATE.UNCOMMITTED;
+        default:
+          return _constants.RENDER_STATE.INACTIVE;
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_getFeatureRenderState", function (id, renderState) {
+      var _this$state5 = _this.state,
+        selectedFeatureId = _this$state5.selectedFeatureId,
+        hoveredFeatureId = _this$state5.hoveredFeatureId;
+      if (renderState) {
+        return renderState;
+      }
+      switch (id) {
+        case selectedFeatureId:
+          return _constants.RENDER_STATE.SELECTED;
+        case hoveredFeatureId:
+          return _constants.RENDER_STATE.HOVERED;
+        case UNCOMMITTED_ID:
+          return _constants.RENDER_STATE.UNCOMMITTED;
+        default:
+          return _constants.RENDER_STATE.INACTIVE;
+      }
+    });
+    /* RENDER */
+    /* eslint-disable max-params */
+    (0, _defineProperty2["default"])(_this, "_renderVertex", function (position, featureIndex, vertexIndex, operation, style, shape) {
+      /* eslint-enable max-params */
+      var p = _this._project(position);
+      if (!p) {
+        return null;
+      }
+      var clickRadius = _this.props.clickRadius;
+      var elemKey = "".concat(_constants.ELEMENT_TYPE.VERTEX, ".").concat(featureIndex, ".").concat(vertexIndex, ".").concat(operation);
+      // first <circle|rect> is to make path easily interacted with
+      switch (shape) {
+        case 'circle':
+          return /*#__PURE__*/_react["default"].createElement("g", {
+            key: elemKey,
+            transform: "translate(".concat(p[0], ", ").concat(p[1], ")")
+          }, /*#__PURE__*/_react["default"].createElement("circle", {
+            "data-type": _constants.ELEMENT_TYPE.VERTEX,
+            "data-feature-index": featureIndex,
+            "data-vertex-index": vertexIndex,
+            "data-operation": operation,
+            key: "".concat(elemKey, ".hidden"),
+            style: _objectSpread(_objectSpread(_objectSpread({}, style), _style.HIDDEN_CLICKABLE_STYLE), {}, {
+              stroke: 'none'
+            }),
+            cx: 0,
+            cy: 0,
+            r: clickRadius
+          }), /*#__PURE__*/_react["default"].createElement("circle", {
+            "data-type": _constants.ELEMENT_TYPE.VERTEX,
+            "data-feature-index": featureIndex,
+            "data-vertex-index": vertexIndex,
+            "data-operation": operation,
+            key: elemKey,
+            style: style,
+            cx: 0,
+            cy: 0
+          }));
+        case 'rect':
+          return /*#__PURE__*/_react["default"].createElement("g", {
+            key: "vertex.".concat(vertexIndex),
+            transform: "translate(".concat(p[0], ", ").concat(p[1], ")")
+          }, /*#__PURE__*/_react["default"].createElement("rect", {
+            "data-type": _constants.ELEMENT_TYPE.VERTEX,
+            "data-feature-index": featureIndex,
+            "data-vertex-index": vertexIndex,
+            "data-operation": operation,
+            key: "".concat(elemKey, ".hidden"),
+            style: _objectSpread(_objectSpread(_objectSpread({}, style), _style.HIDDEN_CLICKABLE_STYLE), {}, {
+              width: clickRadius,
+              height: clickRadius
+            })
+          }), /*#__PURE__*/_react["default"].createElement("rect", {
+            "data-type": _constants.ELEMENT_TYPE.VERTEX,
+            "data-feature-index": featureIndex,
+            "data-vertex-index": vertexIndex,
+            "data-operation": operation,
+            key: elemKey,
+            style: style
+          }));
+        default:
+          return null;
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_renderSegment", function (featureIndex, startVertexId, startPos, endPos) {
+      var style = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+      var clickRadius = _this.props.clickRadius;
+      var projected = _this._getProjectedData([startPos, endPos], _constants.RENDER_TYPE.LINE_STRING);
+      var radius = style.radius,
+        others = (0, _objectWithoutProperties2["default"])(style, _excluded);
+      var elemKey = "".concat(_constants.ELEMENT_TYPE.SEGMENT, ".").concat(featureIndex, ".").concat(startVertexId);
+      return /*#__PURE__*/_react["default"].createElement("g", {
+        key: elemKey
+      }, /*#__PURE__*/_react["default"].createElement("path", {
+        "data-type": _constants.ELEMENT_TYPE.SEGMENT,
+        "data-feature-index": featureIndex,
+        "data-vertex-index": startVertexId,
+        key: "".concat(elemKey, ".hidden"),
+        style: _objectSpread(_objectSpread({}, others), {}, {
+          strokeWidth: clickRadius || radius,
+          opacity: 0
+        }),
+        d: projected
+      }), /*#__PURE__*/_react["default"].createElement("path", {
+        "data-type": _constants.ELEMENT_TYPE.SEGMENT,
+        "data-feature-index": featureIndex,
+        "data-vertex-index": startVertexId,
+        key: elemKey,
+        style: others,
+        d: projected
+      }));
+    });
+    (0, _defineProperty2["default"])(_this, "_renderCommittedStroke", function (featureIndex, feature, style) {
+      var points = feature.points,
+        isClosed = feature.isClosed,
+        renderType = feature.renderType;
+      if (!points || points.length < 2 || renderType === _constants.RENDER_TYPE.RECTANGLE && !isClosed) {
+        return null;
+      }
+      var segments = [];
+      for (var i = 0; i < points.length - 1; i++) {
+        segments.push(_this._renderSegment(featureIndex, i, points[i], points[i + 1], style));
+      }
+      if (isClosed) {
+        var lastIndex = points.length - 1;
+        segments.push(_this._renderSegment(featureIndex, lastIndex, points[lastIndex], points[0], style));
+      }
+      return /*#__PURE__*/_react["default"].createElement("g", {
+        key: "committed group"
+      }, segments);
+    });
+    (0, _defineProperty2["default"])(_this, "_renderUncommittedStrokes", function (featureIndex, feature, style) {
+      var points = feature.points,
+        isClosed = feature.isClosed,
+        renderType = feature.renderType;
+      var mode = _this.props.mode;
+      var uncommittedLngLat = _this.state.uncommittedLngLat;
+      var isDrawing = _constants.DRAWING_MODES.find(function (m) {
+        return m === mode;
+      });
+      if (!points || isClosed || !isDrawing) {
+        return null;
+      }
+      var uncommittedSegments = [];
+      if (renderType === _constants.RENDER_TYPE.RECTANGLE) {
+        for (var i = 0; i < points.length - 1; i++) {
+          uncommittedSegments.push(_this._renderSegment(featureIndex, i, points[i], points[i + 1], style));
+        }
+        if (points.length === 4) {
+          uncommittedSegments.push(_this._renderSegment(featureIndex, 3, points[3], points[0], style));
+        }
+      }
+      if (!uncommittedLngLat) {
+        return uncommittedSegments.length ? uncommittedSegments : null;
+      }
+
+      /* eslint-disable no-inline-comments */
+      uncommittedSegments.push(_this._renderSegment(featureIndex, points.length - 1,
+      // id
+      points.slice(-1)[0],
+      // startPos
+      uncommittedLngLat,
+      // endPos
+      style));
+      /* eslint-enable no-inline-comments */
+
+      return uncommittedSegments.filter(Boolean);
+    });
+    (0, _defineProperty2["default"])(_this, "_renderClosingStroke", function (featureIndex, feature, style) {
+      var points = feature.points,
+        isClosed = feature.isClosed;
+      var mode = _this.props.mode;
+      var uncommittedLngLat = _this.state.uncommittedLngLat;
+      if (uncommittedLngLat && mode === _constants.MODES.DRAW_POLYGON && points.length > 2 && !isClosed) {
+        // from uncommitted position to the first point of the polygon
+        return _this._renderSegment(featureIndex, 'uncommitted-close', uncommittedLngLat, points[0], style);
+      }
+      return null;
+    });
+    (0, _defineProperty2["default"])(_this, "_renderFill", function (index, feature, style) {
+      var mode = _this.props.mode;
+      var isDrawing = _constants.DRAWING_MODES.find(function (m) {
+        return m === mode;
+      });
+      var points = feature.points,
+        renderType = feature.renderType,
+        isClosed = feature.isClosed;
+      if (renderType !== _constants.RENDER_TYPE.POLYGON && renderType !== _constants.RENDER_TYPE.RECTANGLE) {
+        return null;
+      }
+      var uncommittedLngLat = _this.state.uncommittedLngLat;
+      var fillPoints = points;
+      if (uncommittedLngLat && isDrawing) {
+        fillPoints = [].concat((0, _toConsumableArray2["default"])(points), [uncommittedLngLat]);
+      }
+      var fillPath = _this._getProjectedData(fillPoints, renderType, isClosed);
+      return /*#__PURE__*/_react["default"].createElement("path", {
+        "data-type": _constants.ELEMENT_TYPE.FEATURE,
+        "data-feature-index": index,
+        key: "".concat(_constants.ELEMENT_TYPE.FEATURE, ".").concat(index, ".fill"),
+        style: _objectSpread(_objectSpread({}, style), {}, {
+          stroke: 'none'
+        }),
+        d: fillPath
+      });
+    });
+    (0, _defineProperty2["default"])(_this, "_renderCurrentPath", function (feature, index) {
+      var points = feature.points,
+        renderType = feature.renderType;
+      if (!points || !points.length || renderType === _constants.RENDER_TYPE.POINT) {
+        return null;
+      }
+      var getFeatureStyle = _this.props.getFeatureStyle;
+      var geoJson = feature.toFeature();
+      var committedStyle = getFeatureStyle({
+        feature: geoJson,
+        state: _constants.RENDER_STATE.SELECTED
+      });
+      var uncommittedStyle = getFeatureStyle({
+        feature: geoJson,
+        state: _constants.RENDER_STATE.UNCOMMITTED
+      });
+      var closingStyle = getFeatureStyle({
+        feature: geoJson,
+        state: _constants.RENDER_STATE.CLOSING
+      });
+      var committedStroke = _this._renderCommittedStroke(index, feature, committedStyle);
+      var uncommittedStrokes = _this._renderUncommittedStrokes(index, feature, uncommittedStyle) || [];
+      var closingStroke = _this._renderClosingStroke(index, feature, closingStyle);
+      var fill = _this._renderFill(index, feature, uncommittedStyle);
+      return [fill, committedStroke].concat((0, _toConsumableArray2["default"])(uncommittedStrokes), [closingStroke]).filter(Boolean);
+    });
+    (0, _defineProperty2["default"])(_this, "_renderCommittedVertices", function (featureIndex, feature, geoJson) {
+      var _this$props2 = _this.props,
+        mode = _this$props2.mode,
+        getEditHandleStyle = _this$props2.getEditHandleStyle,
+        getEditHandleShape = _this$props2.getEditHandleShape;
+      var isClosed = feature.isClosed,
+        points = feature.points;
+      var committedVertices = [];
+      for (var i = 0; i < points.length; i++) {
+        var p = points[i];
+        var operation = _constants.OPERATIONS.SET;
+        var style = getEditHandleStyle({
+          feature: geoJson,
+          index: i,
+          state: _this._getEditHandleState(i)
+        });
+        var shape = typeof getEditHandleShape === 'function' ? getEditHandleShape({
+          feature: geoJson,
+          index: i,
+          state: _this._getEditHandleState(i)
+        }) : getEditHandleShape;
+        if (isClosed) {
+          committedVertices.push(_this._renderVertex(p, featureIndex, i, operation, style, shape));
+        } else {
+          if (mode === _constants.MODES.DRAW_POLYGON && i === 0 && points.length > 2) {
+            operation = _constants.OPERATIONS.INTERSECT;
+          }
+          committedVertices.push(_this._renderVertex(p, featureIndex, i, operation, style, shape));
+        }
+      }
+      return committedVertices;
+    });
+    (0, _defineProperty2["default"])(_this, "_renderUncommittedVertex", function (featureIndex, feature, geoJson) {
+      var _this$props3 = _this.props,
+        getEditHandleStyle = _this$props3.getEditHandleStyle,
+        getEditHandleShape = _this$props3.getEditHandleShape;
+      var _this$state6 = _this.state,
+        selectedFeatureId = _this$state6.selectedFeatureId,
+        uncommittedLngLat = _this$state6.uncommittedLngLat;
+      var id = feature.id;
+      var uncommittedVertex = null;
+      if (selectedFeatureId === id && uncommittedLngLat) {
+        var style = getEditHandleStyle({
+          feature: geoJson,
+          index: 'uncommitted',
+          state: _this._getEditHandleState(-1, _constants.RENDER_STATE.UNCOMMITTED)
+        });
+        var shape = typeof getEditHandleShape === 'function' ? getEditHandleShape({
+          feature: geoJson,
+          index: null,
+          state: _this._getEditHandleState(-1)
+        }) : getEditHandleShape;
+        uncommittedVertex = _this._renderVertex(uncommittedLngLat, featureIndex, 'uncommitted', _constants.OPERATIONS.INSERT, _objectSpread(_objectSpread({}, style), {}, {
+          pointerEvents: 'none'
+        }), shape);
+      }
+      return uncommittedVertex;
+    });
+    (0, _defineProperty2["default"])(_this, "_renderCurrentVertices", function (feature, featureIndex) {
+      var points = feature.points;
+      if (!points || !points.length) {
+        return null;
+      }
+      var geoJson = feature.toFeature();
+      var committedVertices = _this._renderCommittedVertices(featureIndex, feature, geoJson);
+      var uncommittedVertex = _this._renderUncommittedVertex(featureIndex, feature, geoJson);
+      return /*#__PURE__*/_react["default"].createElement("g", {
+        key: "edit-handles"
+      }, committedVertices, uncommittedVertex);
+    });
+    (0, _defineProperty2["default"])(_this, "_renderCurrent", function () {
+      var features = _this.state.features;
+      var feature = _this._getSelectedFeature();
+      if (!features || !feature || !feature.points) {
+        return null;
+      }
+      var mode = _this.props.mode;
+      var index = features.findIndex(function (f) {
+        return f.id === feature.id;
+      });
+      return /*#__PURE__*/_react["default"].createElement("g", {
+        key: "feature current",
+        style: mode === _constants.MODES.READ_ONLY || mode === _constants.MODES.SELECT_FEATURE ? _constants.STATIC_STYLE : null
+      }, _this._renderCurrentPath(feature, index), _this._renderCurrentVertices(feature, index));
+    });
+    (0, _defineProperty2["default"])(_this, "_renderFeature", function (feature, index) {
+      if (feature === _this._getSelectedFeature()) {
+        return null;
+      }
+      var clickRadius = _this.props.clickRadius;
+      var id = feature.id,
+        points = feature.points,
+        renderType = feature.renderType,
+        isClosed = feature.isClosed;
+      if (!points || !points.length) {
+        return null;
+      }
+      var projected = _this._getProjectedData(points, renderType, isClosed);
+      if (!projected) {
+        return null;
+      }
+      var geoJson = feature.toFeature();
+      var renderState = _this._getFeatureRenderState(id);
+      var _this$props4 = _this.props,
+        getFeatureStyle = _this$props4.getFeatureStyle,
+        getFeatureShape = _this$props4.getFeatureShape;
+      var style = getFeatureStyle({
+        feature: geoJson,
+        state: renderState
+      });
+      var shape = typeof getFeatureShape === 'function' ? getFeatureShape({
+        feature: geoJson,
+        state: renderState
+      }) : getFeatureShape;
+      var elemKey = "".concat(_constants.ELEMENT_TYPE.FEATURE, ".").concat(index);
+      switch (renderType) {
+        case _constants.RENDER_TYPE.POINT:
+          if (shape === 'rect') {
+            return /*#__PURE__*/_react["default"].createElement("g", {
+              key: elemKey,
+              transform: "translate(".concat(projected[0][0], ", ").concat(projected[0][1], ")")
+            }, /*#__PURE__*/_react["default"].createElement("rect", {
+              "data-type": _constants.ELEMENT_TYPE.FEATURE,
+              "data-feature-index": index,
+              key: "".concat(elemKey, ".hidden"),
+              style: _objectSpread(_objectSpread(_objectSpread({}, style), _style.HIDDEN_CLICKABLE_STYLE), {}, {
+                width: clickRadius,
+                height: clickRadius
+              })
+            }), /*#__PURE__*/_react["default"].createElement("rect", {
+              "data-type": _constants.ELEMENT_TYPE.FEATURE,
+              "data-feature-index": index,
+              key: elemKey,
+              style: style
+            }));
+          }
+          return /*#__PURE__*/_react["default"].createElement("g", {
+            key: elemKey,
+            transform: "translate(".concat(projected[0][0], ", ").concat(projected[0][1], ")")
+          }, /*#__PURE__*/_react["default"].createElement("circle", {
+            "data-type": _constants.ELEMENT_TYPE.FEATURE,
+            "data-feature-index": index,
+            key: "".concat(elemKey, ".hidden"),
+            style: _objectSpread(_objectSpread({}, style), {}, {
+              opacity: 0
+            }),
+            cx: 0,
+            cy: 0,
+            r: clickRadius
+          }), /*#__PURE__*/_react["default"].createElement("circle", {
+            "data-type": _constants.ELEMENT_TYPE.FEATURE,
+            "data-feature-index": index,
+            key: "feature.".concat(index),
+            style: style,
+            cx: 0,
+            cy: 0
+          }));
+
+        // first <path> is to make path easily interacted with
+        case _constants.RENDER_TYPE.LINE_STRING:
+          return /*#__PURE__*/_react["default"].createElement("g", {
+            key: elemKey
+          }, /*#__PURE__*/_react["default"].createElement("path", {
+            "data-type": _constants.ELEMENT_TYPE.FEATURE,
+            "data-feature-index": index,
+            key: "".concat(elemKey, ".hidden"),
+            style: _objectSpread(_objectSpread({}, style), {}, {
+              strokeWidth: clickRadius,
+              opacity: 0
+            }),
+            d: projected
+          }), /*#__PURE__*/_react["default"].createElement("path", {
+            "data-type": _constants.ELEMENT_TYPE.FEATURE,
+            "data-feature-index": index,
+            key: elemKey,
+            style: style,
+            d: projected
+          }));
+        case 'Polygon':
+        case 'Rectangle':
+          return /*#__PURE__*/_react["default"].createElement("path", {
+            "data-type": _constants.ELEMENT_TYPE.FEATURE,
+            "data-feature-index": index,
+            key: elemKey,
+            style: style,
+            d: projected
+          });
+        default:
+          return null;
+      }
+    });
+    (0, _defineProperty2["default"])(_this, "_renderFeatures", function () {
+      var features = _this.state.features;
+      return features && features.map(_this._renderFeature);
+    });
+    (0, _defineProperty2["default"])(_this, "_renderCanvas", function () {
+      var _this$state7 = _this.state,
+        selectedFeatureId = _this$state7.selectedFeatureId,
+        features = _this$state7.features;
+      return /*#__PURE__*/_react["default"].createElement("svg", {
+        key: "draw-canvas",
+        width: "100%",
+        height: "100%"
+      }, features && features.length > 0 && /*#__PURE__*/_react["default"].createElement("g", {
+        key: "feature-group"
+      }, _this._renderFeatures()), selectedFeatureId && _this._renderCurrent());
+    });
+    (0, _defineProperty2["default"])(_this, "_renderEditor", function () {
+      var viewport = _this._context && _this._context.viewport || {};
+      var style = _this.props.style;
+      var width = viewport.width,
+        height = viewport.height;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        id: "editor",
+        style: _objectSpread({
+          width: width,
+          height: height
+        }, style),
+        ref: function ref(_) {
+          _this._containerRef = _;
+        }
+      }, _this._renderCanvas());
+    });
+    _this.state = {
+      features: props.features ? props.features.map(function (f) {
+        return _feature2["default"].fromFeature(f);
+      }).filter(Boolean) : null,
+      selectedFeatureId: -1,
+      hoveredFeatureId: null,
+      hoveredLngLat: null,
+      hoveredVertexIndex: -1,
+      // intermediate mouse position when drawing
+      uncommittedLngLat: null,
+      draggingVertexIndex: -1,
+      startDragPos: null,
+      isDragging: false,
+      didDrag: false
+    };
+    _this._containerRef = null;
+    _this._events = {};
+    _this._context = null;
+    return _this;
+  }
+  (0, _inherits2["default"])(Editor, _PureComponent);
+  return (0, _createClass2["default"])(Editor, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.mode && this.props.mode !== _constants.MODES.READ_ONLY) {
+        this._setupEvents();
+      }
+    }
+  }, {
+    key: "componentWillReceiveProps",
+    value: function componentWillReceiveProps(nextProps) {
+      if (this.props.mode !== nextProps.mode) {
+        if (!nextProps.mode || nextProps.mode === _constants.MODES.READ_ONLY) {
+          this._removeEvents();
+        }
+        if (!this.props.mode || this.props.mode === _constants.MODES.READ_ONLY) {
+          this._setupEvents();
+        }
+      }
+      if (this.props.mode !== nextProps.mode || this.props.features !== nextProps.features) {
+        this.setState({
+          features: nextProps.features && nextProps.features.map(function (f) {
+            return _feature2["default"].fromFeature(f);
+          }).filter(Boolean)
+        });
+      }
+      if (this.props.mode !== nextProps.mode || this.props.selectedFeatureId !== nextProps.selectedFeatureId) {
+        this._clearCache();
+        this.setState({
+          selectedFeatureId: nextProps.selectedFeatureId
+        });
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._removeEvents();
+    }
+  }, {
+    key: "_setupEvents",
+    value: /* EVENTS */
+    function _setupEvents() {
+      var _this2 = this;
+      var ref = this._containerRef;
+      if (!ref || !this._context || !this._context.eventManager) {
+        return;
+      }
+      this._events = {
+        anyclick: function anyclick(evt) {
+          return _this2._onEvent(_this2._onClick, evt, true);
+        },
+        click: function click(evt) {
+          return evt.stopImmediatePropagation();
+        },
+        pointermove: function pointermove(evt) {
+          return _this2._onEvent(_this2._onMouseMove, evt, true);
+        },
+        pointerdown: function pointerdown(evt) {
+          return _this2._onEvent(_this2._onMouseDown, evt, true);
+        },
+        pointerup: function pointerup(evt) {
+          return _this2._onEvent(_this2._onMouseUp, evt, true);
+        },
+        panmove: function panmove(evt) {
+          return _this2._onEvent(_this2._onPan, evt, false);
+        },
+        panstart: function panstart(evt) {
+          return _this2._onEvent(_this2._onPan, evt, false);
+        },
+        panend: function panend(evt) {
+          return _this2._onEvent(_this2._onPan, evt, false);
+        }
+      };
+      this._context.eventManager.on(this._events, ref);
+    }
+  }, {
+    key: "_removeEvents",
+    value: function _removeEvents() {
+      if (!this._context || !this._context.eventManager || !this._events) {
+        return;
+      }
+      this._context.eventManager.off(this._events);
+      this._events = null;
+    }
+  }, {
+    key: "_getProjectedData",
+    value: function _getProjectedData(points, renderType) {
+      var _this3 = this;
+      var isClosed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      if (points.length === 0) {
+        return '';
+      }
+      var projected = points.map(function (p) {
+        return _this3._project(p);
+      });
+      switch (renderType) {
+        case _constants.RENDER_TYPE.POINT:
+          return projected;
+        case _constants.RENDER_TYPE.LINE_STRING:
+        case _constants.RENDER_TYPE.POLYGON:
+        case _constants.RENDER_TYPE.RECTANGLE:
+          var pathString = projected.map(function (p) {
+            return "".concat(p[0], ",").concat(p[1]);
+          }).join('L');
+          return "M ".concat(pathString, " ").concat(isClosed ? 'z' : '');
+        default:
+          return null;
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this4 = this;
+      return /*#__PURE__*/_react["default"].createElement(_reactMapGl._MapContext.Consumer, null, function (context) {
+        _this4._context = context;
+        var viewport = context && context.viewport;
+        if (!viewport || viewport.height <= 0 || viewport.width <= 0) {
+          return null;
+        }
+        return _this4._renderEditor();
+      });
+    }
+  }]);
+}(_react.PureComponent);
+(0, _defineProperty2["default"])(Editor, "defaultProps", defaultProps);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reactMapGl","_uuid","_feature2","_interopRequireDefault","_style","_constants","_utils","_excluded","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ownKeys","keys","getOwnPropertySymbols","o","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","_callSuper","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","Boolean","prototype","valueOf","defaultProps","mode","MODES","READ_ONLY","clickRadius","getEditHandleStyle","defaultGetEditHandleStyle","getFeatureStyle","defaultGetFeatureStyle","getFeatureShape","getEditHandleShape","onSelect","UNCOMMITTED_ID","Editor","exports","_PureComponent","props","_this","_classCallCheck2","features","onUpdate","map","f","toFeature","feature","options","vertexIndex","lngLat","diagonal","p0","points","replacePoint","_update","state","renderType","RENDER_TYPE","RECTANGLE","_updateRectangle","dx","dy","pixels","_project","_unproject","x","y","isNew","undefined","_getSelectedFeature","addPoint","validPath","_this$props","DRAW_POINT","DRAW_PATH","selectedFeatureId","id","setState","_toConsumableArray2","uncommittedLngLat","hoveredFeatureId","hoveredLngLat","hoveredVertexIndex","draggingVertexIndex","startDragPos","isDragging","didDrag","selectedFeature","closePath","point","type","MODE_TO_GEOJSON_TYPE","MODE_TO_RENDER_TYPE","Feature","uuid","_addPoint","DRAW_RECTANGLE","handler","evt","stopPropagation","_len","args","Array","_key","concat","stopImmediatePropagation","Number","_this$_getEventPositi","_getEventPosition","attributes","parseElemDataAttributes","target","ELEMENT_TYPE","VERTEX","_matchesFeature","featureIndex","_this$state","_this$_getEventPositi2","isDrawing","DRAWING_MODES","indexOf","isEditing","EDIT_VERTEX","_updateFeature","LINE_STRING","POLYGON","SEGMENT","_getClosestPositionOnSegment","_this$state2","FEATURE","sourceEvent","operation","OPERATIONS","INTERSECT","SET","_closePath","_clearCache","_this$_getEventPositi3","insertPosition","insertPoint","_onClickVertex","_onClickSegment","SELECT_FEATURE","_onClickFeature","_this$_getEventPositi4","_addFeature","DRAW_POLYGON","isClosed","pt","_context","viewport","project","unproject","elemFeature","pointLngLat","startPos","endPos","findClosestPointOnLineSegment","_evt$offsetCenter","offsetCenter","_this$state3","find","index","renderState","_this$state4","isSelected","POINT","isClosing","RENDER_STATE","CLOSING","SELECTED","HOVERED","UNCOMMITTED","INACTIVE","_this$state5","position","style","shape","p","elemKey","createElement","key","transform","HIDDEN_CLICKABLE_STYLE","stroke","cx","cy","width","height","startVertexId","projected","_getProjectedData","radius","others","_objectWithoutProperties2","strokeWidth","opacity","d","segments","_renderSegment","lastIndex","m","uncommittedSegments","slice","fillPoints","fillPath","geoJson","committedStyle","uncommittedStyle","closingStyle","committedStroke","_renderCommittedStroke","uncommittedStrokes","_renderUncommittedStrokes","closingStroke","_renderClosingStroke","fill","_renderFill","_this$props2","committedVertices","_getEditHandleState","_renderVertex","_this$props3","_this$state6","uncommittedVertex","INSERT","pointerEvents","_renderCommittedVertices","_renderUncommittedVertex","findIndex","STATIC_STYLE","_renderCurrentPath","_renderCurrentVertices","_getFeatureRenderState","_this$props4","_renderFeature","_this$state7","_renderFeatures","_renderCurrent","ref","_","_containerRef","_renderCanvas","fromFeature","_events","_inherits2","_createClass2","value","componentDidMount","_setupEvents","componentWillReceiveProps","nextProps","_removeEvents","componentWillUnmount","_this2","eventManager","anyclick","_onEvent","_onClick","click","pointermove","_onMouseMove","pointerdown","_onMouseDown","pointerup","_onMouseUp","panmove","_onPan","panstart","panend","on","off","_this3","pathString","join","render","_this4","_MapContext","Consumer","context","_renderEditor","PureComponent"],"sources":["../../../src/vendor/react-map-gl-draw/editor.js"],"sourcesContent":["// Vendored from react-map-gl-draw@0.14.8 (MIT, Copyright (c) 2018 Uber Technologies, Inc.), see ./LICENSE\n/* eslint-disable complexity, max-statements */\nimport React, {PureComponent} from 'react';\nimport {_MapContext as MapContext} from 'react-map-gl';\nimport {v4 as uuid} from 'uuid';\n\nimport Feature from './feature';\nimport {\n  getEditHandleStyle as defaultGetEditHandleStyle,\n  getFeatureStyle as defaultGetFeatureStyle,\n  HIDDEN_CLICKABLE_STYLE\n} from './style';\n\nimport {\n  OPERATIONS,\n  MODES,\n  DRAWING_MODES,\n  MODE_TO_GEOJSON_TYPE,\n  MODE_TO_RENDER_TYPE,\n  RENDER_STATE,\n  RENDER_TYPE,\n  STATIC_STYLE,\n  ELEMENT_TYPE\n} from './constants';\nimport {parseElemDataAttributes, findClosestPointOnLineSegment} from './utils';\n\nconst defaultProps = {\n  mode: MODES.READ_ONLY,\n  clickRadius: 0,\n  getEditHandleStyle: defaultGetEditHandleStyle,\n  getFeatureStyle: defaultGetFeatureStyle,\n  getFeatureShape: 'circle',\n  getEditHandleShape: 'circle',\n  onSelect: () => {}\n};\n\nconst UNCOMMITTED_ID = 'uncommitted';\n\nexport default class Editor extends PureComponent {\n  static defaultProps = defaultProps;\n\n  constructor(props) {\n    super(props);\n    this.state = {\n      features: props.features\n        ? props.features.map(f => Feature.fromFeature(f)).filter(Boolean)\n        : null,\n\n      selectedFeatureId: -1,\n\n      hoveredFeatureId: null,\n      hoveredLngLat: null,\n      hoveredVertexIndex: -1,\n\n      // intermediate mouse position when drawing\n      uncommittedLngLat: null,\n\n      draggingVertexIndex: -1,\n      startDragPos: null,\n      isDragging: false,\n      didDrag: false\n    };\n\n    this._containerRef = null;\n    this._events = {};\n    this._context = null;\n  }\n\n  componentDidMount() {\n    if (this.props.mode && this.props.mode !== MODES.READ_ONLY) {\n      this._setupEvents();\n    }\n  }\n\n  componentWillReceiveProps(nextProps) {\n    if (this.props.mode !== nextProps.mode) {\n      if (!nextProps.mode || nextProps.mode === MODES.READ_ONLY) {\n        this._removeEvents();\n      }\n      if (!this.props.mode || this.props.mode === MODES.READ_ONLY) {\n        this._setupEvents();\n      }\n    }\n\n    if (this.props.mode !== nextProps.mode || this.props.features !== nextProps.features) {\n      this.setState({\n        features:\n          nextProps.features && nextProps.features.map(f => Feature.fromFeature(f)).filter(Boolean)\n      });\n    }\n\n    if (\n      this.props.mode !== nextProps.mode ||\n      this.props.selectedFeatureId !== nextProps.selectedFeatureId\n    ) {\n      this._clearCache();\n      this.setState({\n        selectedFeatureId: nextProps.selectedFeatureId\n      });\n    }\n  }\n\n  componentWillUnmount() {\n    this._removeEvents();\n  }\n\n  _containerRef;\n  _events;\n  _context;\n\n  /* FEATURE OPERATIONS */\n  _update = features => {\n    if (features) {\n      this.props.onUpdate(features.map(f => f.toFeature()));\n    }\n  };\n\n  _updateRectangle = (feature, options) => {\n    const {vertexIndex, lngLat} = options;\n    /*\n     *   p0.x, p0.y   ----------  diagonal.x, p0.y\n     *       |                             |\n     *       |                             |\n     *   p0.x, diagonal.y ----- diagonal.x, diagonal.y\n     */\n    const diagonal = vertexIndex;\n    const p0 = feature.points[(diagonal + 2) % 4];\n\n    feature.replacePoint(diagonal, [lngLat[0], lngLat[1]]);\n    feature.replacePoint((diagonal + 1) % 4, [lngLat[0], p0[1]]);\n    feature.replacePoint((diagonal + 3) % 4, [p0[0], lngLat[1]]);\n\n    this._update(this.state.features);\n  };\n\n  _updateFeature = (feature, mode, options) => {\n    switch (mode) {\n      case 'vertex':\n        if (feature.renderType === RENDER_TYPE.RECTANGLE) {\n          this._updateRectangle(feature, options);\n        } else {\n          feature.replacePoint(options.vertexIndex, [options.lngLat[0], options.lngLat[1]]);\n          this._update(this.state.features);\n        }\n        break;\n\n      case 'feature':\n        const {dx, dy} = options;\n        feature.points = feature.points\n          .map(lngLat => {\n            const pixels = this._project(lngLat);\n            if (pixels) {\n              pixels[0] += dx;\n              pixels[1] += dy;\n              return this._unproject(pixels);\n            }\n            return null;\n          })\n          .filter(Boolean);\n\n        this._update(this.state.features);\n        break;\n\n      case 'Rectangle':\n        this._updateRectangle(feature, options);\n        break;\n\n      default:\n    }\n  };\n\n  _addPoint = (x, y, feature, isNew = false) => {\n    feature = feature || this._getSelectedFeature();\n\n    if (!feature) {\n      return;\n    }\n\n    const lngLat = this._unproject([x, y]);\n    if (!lngLat) {\n      return;\n    }\n\n    feature.addPoint([lngLat[0], lngLat[1]]);\n\n    const features = this.state.features || [];\n    if (isNew) {\n      features.push(feature);\n    }\n\n    const validPath = feature.points && feature.points.length >= 2;\n    const {mode, onSelect} = this.props;\n\n    if (mode === MODES.DRAW_POINT || (mode === MODES.DRAW_PATH && validPath)) {\n      this._update(features);\n      onSelect({selectedFeatureId: feature && feature.id});\n    } else {\n      this.setState({\n        features: [...features],\n        selectedFeatureId: feature && feature.id\n      });\n    }\n  };\n\n  _clearCache = () => {\n    this.setState({\n      selectedFeatureId: null,\n      uncommittedLngLat: null,\n\n      hoveredFeatureId: null,\n      hoveredLngLat: null,\n      hoveredVertexIndex: -1,\n\n      draggingVertexIndex: -1,\n      startDragPos: null,\n      isDragging: false,\n      didDrag: false\n    });\n  };\n\n  _closePath = () => {\n    const selectedFeature = this._getSelectedFeature();\n    if (selectedFeature) {\n      selectedFeature.closePath();\n      this._update(this.state.features);\n    }\n  };\n\n  _addFeature = (mode, point) => {\n    const type = MODE_TO_GEOJSON_TYPE[mode];\n    const renderType = MODE_TO_RENDER_TYPE[mode];\n\n    const feature = new Feature({\n      id: uuid(),\n      type,\n      renderType\n    });\n\n    this._addPoint(point.x, point.y, feature, true);\n\n    if (mode === MODES.DRAW_RECTANGLE) {\n      for (let i = 0; i < 3; i++) {\n        this._addPoint(point.x, point.y, feature, false);\n      }\n    }\n  };\n\n  /* EVENTS */\n  _setupEvents() {\n    const ref = this._containerRef;\n\n    if (!ref || !this._context || !this._context.eventManager) {\n      return;\n    }\n\n    this._events = {\n      anyclick: evt => this._onEvent(this._onClick, evt, true),\n      click: evt => evt.stopImmediatePropagation(),\n      pointermove: evt => this._onEvent(this._onMouseMove, evt, true),\n      pointerdown: evt => this._onEvent(this._onMouseDown, evt, true),\n      pointerup: evt => this._onEvent(this._onMouseUp, evt, true),\n      panmove: evt => this._onEvent(this._onPan, evt, false),\n      panstart: evt => this._onEvent(this._onPan, evt, false),\n      panend: evt => this._onEvent(this._onPan, evt, false)\n    };\n\n    this._context.eventManager.on(this._events, ref);\n  }\n\n  _removeEvents() {\n    if (!this._context || !this._context.eventManager || !this._events) {\n      return;\n    }\n    this._context.eventManager.off(this._events);\n    this._events = null;\n  }\n\n  _onEvent = (handler, evt, stopPropagation, ...args) => {\n    const {mode} = this.props;\n    if (mode === MODES.READ_ONLY) {\n      return;\n    }\n\n    handler(evt, ...args);\n\n    if (stopPropagation) {\n      evt.stopImmediatePropagation();\n    }\n  };\n\n  _onMouseUp = evt => {\n    this.setState({\n      isDragging: false,\n      didDrag: false\n    });\n    const {draggingVertexIndex} = this.state;\n\n    if (Number(draggingVertexIndex) >= 0) {\n      this.setState({\n        draggingVertexIndex: -1\n      });\n    }\n  };\n\n  _onMouseDown = evt => {\n    const {x, y} = this._getEventPosition(evt);\n    const attributes = parseElemDataAttributes(evt.target);\n\n    // click segment\n    if (attributes && attributes.type === ELEMENT_TYPE.VERTEX) {\n      const {vertexIndex} = attributes;\n      this.setState({\n        draggingVertexIndex: vertexIndex,\n        startDragPos: {x, y},\n        isDragging: true\n      });\n\n      // click selected feature\n    } else if (this._matchesFeature(attributes, this._getSelectedFeature())) {\n      this.setState({\n        startDragPos: {x, y},\n        isDragging: true\n      });\n    }\n  };\n\n  /* eslint-disable max-depth */\n  _onMouseMove = evt => {\n    const attributes = parseElemDataAttributes(evt.target) || {};\n    const {vertexIndex, featureIndex, type} = attributes;\n\n    const {startDragPos, isDragging, didDrag} = this.state;\n    const {mode} = this.props;\n    const {x, y} = this._getEventPosition(evt);\n    const lngLat = this._unproject([x, y]);\n\n    if (isDragging && !didDrag && startDragPos) {\n      const dx = x - startDragPos.x;\n      const dy = y - startDragPos.y;\n      if (dx * dx + dy * dy > 5) {\n        this.setState({didDrag: true});\n      }\n    }\n\n    const selectedFeature = this._getSelectedFeature();\n    const isDrawing = DRAWING_MODES.indexOf(mode) !== -1;\n    const isEditing = mode === MODES.EDIT_VERTEX;\n\n    if (selectedFeature) {\n      // dragging\n      if (didDrag && startDragPos) {\n        const draggingVertexIndex = Number(this.state.draggingVertexIndex);\n\n        if (draggingVertexIndex >= 0) {\n          // dragging vertex\n          this._updateFeature(selectedFeature, 'vertex', {\n            vertexIndex: draggingVertexIndex,\n            lngLat\n          });\n        } else {\n          // dragging feature\n          const dx = x - startDragPos.x;\n          const dy = y - startDragPos.y;\n          this.setState({startDragPos: {x, y}});\n\n          this._updateFeature(selectedFeature, 'feature', {dx, dy});\n        }\n      } else if (mode === MODES.DRAW_RECTANGLE) {\n        // drawing rectangle\n        this._updateFeature(selectedFeature, 'Rectangle', {vertexIndex: 2, lngLat});\n      } else if (isDrawing) {\n        // drawing other shapes\n        this.setState({uncommittedLngLat: lngLat});\n      } else if (isEditing) {\n        if (\n          (selectedFeature.renderType === RENDER_TYPE.LINE_STRING ||\n            selectedFeature.renderType === RENDER_TYPE.POLYGON) &&\n          type === ELEMENT_TYPE.SEGMENT\n        ) {\n          // segmentId is start vertexIndex\n          let uncommittedLngLat = null;\n          if (lngLat && typeof vertexIndex === 'number') {\n            uncommittedLngLat = this._getClosestPositionOnSegment(\n              vertexIndex,\n              lngLat,\n              selectedFeature\n            );\n          }\n\n          this.setState({\n            uncommittedLngLat\n          });\n        } else {\n          this.setState({\n            uncommittedLngLat: null\n          });\n        }\n      }\n    }\n\n    const {features, selectedFeatureId} = this.state;\n    if (selectedFeatureId && type === ELEMENT_TYPE.VERTEX && typeof featureIndex === 'number') {\n      const feature = features && features[featureIndex];\n      if (selectedFeatureId === (feature && feature.id)) {\n        this.setState({\n          hoveredVertexIndex: vertexIndex\n        });\n      }\n    } else if (type !== ELEMENT_TYPE.VERTEX) {\n      this.setState({\n        hoveredVertexIndex: null\n      });\n    }\n\n    if (type === ELEMENT_TYPE.FEATURE && typeof featureIndex === 'number') {\n      const feature = features && features[featureIndex];\n      this.setState({\n        hoveredFeatureId: feature && feature.id\n      });\n    } else {\n      this.setState({\n        hoveredFeatureId: null\n      });\n    }\n  };\n  /* eslint-enable max-depth */\n\n  _onClickFeature = (evt, attributes) => {\n    const {featureIndex} = attributes;\n    const {features} = this.state;\n    const selectedFeature = features && typeof featureIndex === 'number' && features[featureIndex];\n\n    if (selectedFeature) {\n      this.props.onSelect({\n        selectedFeatureId: selectedFeature.id,\n        sourceEvent: evt\n      });\n    }\n  };\n\n  _onClickVertex = (evt, attributes) => {\n    const {mode} = this.props;\n    const operation = attributes.operation;\n    if (\n      operation === OPERATIONS.INTERSECT ||\n      (operation === OPERATIONS.SET && mode === MODES.DRAW_RECTANGLE)\n    ) {\n      this._closePath();\n      this._clearCache();\n    }\n  };\n\n  _onClickSegment = (evt, attributes) => {\n    const feature = this._getSelectedFeature();\n\n    if (\n      feature &&\n      (feature.renderType === RENDER_TYPE.POLYGON ||\n        feature.renderType === RENDER_TYPE.LINE_STRING) &&\n      attributes\n    ) {\n      const {vertexIndex} = attributes;\n\n      const {uncommittedLngLat} = this.state;\n\n      let lngLat = uncommittedLngLat;\n      if (!lngLat && typeof vertexIndex === 'number') {\n        const {x, y} = this._getEventPosition(evt);\n        lngLat = this._unproject([x, y]);\n        lngLat = this._getClosestPositionOnSegment(vertexIndex, lngLat, feature);\n      }\n\n      if (lngLat) {\n        const insertPosition = (vertexIndex + 1) % feature.points.length;\n        feature.insertPoint(lngLat, insertPosition);\n        this._update(this.state.features);\n      }\n\n      this.setState({\n        uncommittedLngLat: null,\n        hoveredLngLat: null\n      });\n    }\n  };\n\n  _onClick = evt => {\n    const {mode} = this.props;\n    const attributes = parseElemDataAttributes(evt.target);\n\n    if (attributes && attributes.type === ELEMENT_TYPE.VERTEX) {\n      this._onClickVertex(evt, attributes);\n      return;\n    }\n\n    if (mode === MODES.EDIT_VERTEX && attributes && attributes.type === ELEMENT_TYPE.SEGMENT) {\n      this._onClickSegment(evt, attributes);\n      return;\n    }\n\n    if (\n      (mode === MODES.SELECT_FEATURE || mode === MODES.EDIT_VERTEX) &&\n      attributes &&\n      attributes.type === ELEMENT_TYPE.FEATURE\n    ) {\n      this._onClickFeature(evt, attributes);\n      return;\n    }\n\n    const selectedFeature = this._getSelectedFeature();\n    const {x, y} = this._getEventPosition(evt);\n\n    switch (mode) {\n      case MODES.EDIT_VERTEX:\n        if (selectedFeature) {\n          this.props.onSelect({\n            selectedFeatureId: null,\n            sourceEvent: evt\n          });\n        }\n        break;\n\n      case MODES.DRAW_POINT:\n        this._addFeature(mode, {x, y});\n        break;\n\n      case MODES.DRAW_PATH:\n      case MODES.DRAW_POLYGON:\n        if (selectedFeature && selectedFeature.isClosed) {\n          // clicked outside\n          this._clearCache();\n        } else if (selectedFeature) {\n          this._addPoint(x, y, selectedFeature);\n        } else {\n          this._addFeature(mode, {x, y});\n        }\n        break;\n\n      case MODES.DRAW_RECTANGLE:\n        if (selectedFeature && selectedFeature.isClosed) {\n          // clicked outside\n          this._clearCache();\n          this.props.onSelect({\n            selectedFeatureId: null,\n            sourceEvent: evt\n          });\n        } else {\n          this._addFeature(mode, {x, y});\n        }\n\n        break;\n\n      default:\n    }\n  };\n\n  // don't forward pan events to the underlying map when:\n  // - the pan target is a vertex/line/the currently selected feature\n  // - the user is dragging something around\n  // - there is currently an uncommitted position\n  // (i.e. the user is creating a feature/vertex/line)\n  _onPan = evt => {\n    const attributes = parseElemDataAttributes(evt.target);\n    const type = attributes && attributes.type;\n    if (\n      type === ELEMENT_TYPE.VERTEX ||\n      type === ELEMENT_TYPE.SEGMENT ||\n      this.state.isDragging ||\n      this.state.uncommittedLngLat !== null\n    ) {\n      evt.stopImmediatePropagation();\n    }\n  };\n\n  /* HELPERS */\n  // lngLat to pixels\n  _project = pt => {\n    return this._context && this._context.viewport && this._context.viewport.project(pt);\n  };\n\n  // pixels to lngLat\n  _unproject = pt => {\n    return this._context && this._context.viewport && this._context.viewport.unproject(pt);\n  };\n\n  _matchesFeature = (attributes, feature) => {\n    if (!attributes || attributes.type !== ELEMENT_TYPE.FEATURE || !feature) {\n      return false;\n    }\n\n    const {featureIndex} = attributes;\n    const {features} = this.props;\n    const elemFeature = features && features[featureIndex];\n    return elemFeature && feature.id === elemFeature.id;\n  };\n\n  _getClosestPositionOnSegment = (vertexIndex, pointLngLat, feature) => {\n    const points = feature && feature.points;\n    if (!points || !points.length) {\n      return null;\n    }\n\n    // segmentId is start vertexIndex\n    const startPos = points[vertexIndex];\n    const endPos = points[(vertexIndex + 1) % points.length];\n    return findClosestPointOnLineSegment(startPos, endPos, pointLngLat);\n  };\n\n  _getEventPosition = evt => {\n    const {\n      offsetCenter: {x, y}\n    } = evt;\n    return {x: Number(x), y: Number(y)};\n  };\n\n  _getProjectedData(points, renderType, isClosed = false) {\n    if (points.length === 0) {\n      return '';\n    }\n\n    const projected = points.map(p => this._project(p));\n    switch (renderType) {\n      case RENDER_TYPE.POINT:\n        return projected;\n      case RENDER_TYPE.LINE_STRING:\n      case RENDER_TYPE.POLYGON:\n      case RENDER_TYPE.RECTANGLE:\n        const pathString = projected\n          .map(p => {\n            return `${p[0]},${p[1]}`;\n          })\n          .join('L');\n        return `M ${pathString} ${isClosed ? 'z' : ''}`;\n      default:\n        return null;\n    }\n  }\n\n  _getSelectedFeature = () => {\n    const {features, selectedFeatureId} = this.state;\n    return features && features.find(f => f.id === selectedFeatureId);\n  };\n\n  _getEditHandleState = (index, renderState) => {\n    const {mode} = this.props;\n    const {draggingVertexIndex, hoveredVertexIndex} = this.state;\n    const selectedFeature = this._getSelectedFeature();\n    const isSelected =\n      index === draggingVertexIndex ||\n      (selectedFeature && selectedFeature.renderType === RENDER_TYPE.POINT);\n    const isClosing = mode === MODES.DRAW_POLYGON && hoveredVertexIndex === 0 && index === -1;\n\n    if (renderState) {\n      return renderState;\n    }\n\n    if (isClosing) {\n      return RENDER_STATE.CLOSING;\n    }\n\n    if (isSelected) {\n      return RENDER_STATE.SELECTED;\n    }\n\n    switch (index) {\n      case hoveredVertexIndex:\n        return RENDER_STATE.HOVERED;\n      case UNCOMMITTED_ID:\n        return RENDER_STATE.UNCOMMITTED;\n      default:\n        return RENDER_STATE.INACTIVE;\n    }\n  };\n\n  _getFeatureRenderState = (id, renderState) => {\n    const {selectedFeatureId, hoveredFeatureId} = this.state;\n    if (renderState) {\n      return renderState;\n    }\n    switch (id) {\n      case selectedFeatureId:\n        return RENDER_STATE.SELECTED;\n      case hoveredFeatureId:\n        return RENDER_STATE.HOVERED;\n      case UNCOMMITTED_ID:\n        return RENDER_STATE.UNCOMMITTED;\n      default:\n        return RENDER_STATE.INACTIVE;\n    }\n  };\n\n  /* RENDER */\n  /* eslint-disable max-params */\n  _renderVertex = (position, featureIndex, vertexIndex, operation, style, shape) => {\n    /* eslint-enable max-params */\n    const p = this._project(position);\n    if (!p) {\n      return null;\n    }\n\n    const {clickRadius} = this.props;\n\n    const elemKey = `${ELEMENT_TYPE.VERTEX}.${featureIndex}.${vertexIndex}.${operation}`;\n    // first <circle|rect> is to make path easily interacted with\n    switch (shape) {\n      case 'circle':\n        return (\n          <g key={elemKey} transform={`translate(${p[0]}, ${p[1]})`}>\n            <circle\n              data-type={ELEMENT_TYPE.VERTEX}\n              data-feature-index={featureIndex}\n              data-vertex-index={vertexIndex}\n              data-operation={operation}\n              key={`${elemKey}.hidden`}\n              style={{...style, ...HIDDEN_CLICKABLE_STYLE, stroke: 'none'}}\n              cx={0}\n              cy={0}\n              r={clickRadius}\n            />\n            <circle\n              data-type={ELEMENT_TYPE.VERTEX}\n              data-feature-index={featureIndex}\n              data-vertex-index={vertexIndex}\n              data-operation={operation}\n              key={elemKey}\n              style={style}\n              cx={0}\n              cy={0}\n            />\n          </g>\n        );\n      case 'rect':\n        return (\n          <g key={`vertex.${vertexIndex}`} transform={`translate(${p[0]}, ${p[1]})`}>\n            <rect\n              data-type={ELEMENT_TYPE.VERTEX}\n              data-feature-index={featureIndex}\n              data-vertex-index={vertexIndex}\n              data-operation={operation}\n              key={`${elemKey}.hidden`}\n              style={{\n                ...style,\n                ...HIDDEN_CLICKABLE_STYLE,\n                width: clickRadius,\n                height: clickRadius\n              }}\n            />\n            <rect\n              data-type={ELEMENT_TYPE.VERTEX}\n              data-feature-index={featureIndex}\n              data-vertex-index={vertexIndex}\n              data-operation={operation}\n              key={elemKey}\n              style={style}\n            />\n          </g>\n        );\n\n      default:\n        return null;\n    }\n  };\n\n  _renderSegment = (featureIndex, startVertexId, startPos, endPos, style = {}) => {\n    const {clickRadius} = this.props;\n    const projected = this._getProjectedData([startPos, endPos], RENDER_TYPE.LINE_STRING);\n    const {radius, ...others} = style;\n\n    const elemKey = `${ELEMENT_TYPE.SEGMENT}.${featureIndex}.${startVertexId}`;\n    return (\n      <g key={elemKey}>\n        <path\n          data-type={ELEMENT_TYPE.SEGMENT}\n          data-feature-index={featureIndex}\n          data-vertex-index={startVertexId}\n          key={`${elemKey}.hidden`}\n          style={{...others, strokeWidth: clickRadius || radius, opacity: 0}}\n          d={projected}\n        />\n        <path\n          data-type={ELEMENT_TYPE.SEGMENT}\n          data-feature-index={featureIndex}\n          data-vertex-index={startVertexId}\n          key={elemKey}\n          style={others}\n          d={projected}\n        />\n      </g>\n    );\n  };\n\n  _renderCommittedStroke = (featureIndex, feature, style) => {\n    const {points, isClosed, renderType} = feature;\n    if (!points || points.length < 2 || (renderType === RENDER_TYPE.RECTANGLE && !isClosed)) {\n      return null;\n    }\n\n    const segments = [];\n    for (let i = 0; i < points.length - 1; i++) {\n      segments.push(this._renderSegment(featureIndex, i, points[i], points[i + 1], style));\n    }\n\n    if (isClosed) {\n      const lastIndex = points.length - 1;\n      segments.push(\n        this._renderSegment(featureIndex, lastIndex, points[lastIndex], points[0], style)\n      );\n    }\n\n    return <g key=\"committed group\">{segments}</g>;\n  };\n\n  _renderUncommittedStrokes = (featureIndex, feature, style) => {\n    const {points, isClosed, renderType} = feature;\n    const {mode} = this.props;\n    const {uncommittedLngLat} = this.state;\n    const isDrawing = DRAWING_MODES.find(m => m === mode);\n\n    if (!points || isClosed || !isDrawing) {\n      return null;\n    }\n\n    const uncommittedSegments = [];\n\n    if (renderType === RENDER_TYPE.RECTANGLE) {\n      for (let i = 0; i < points.length - 1; i++) {\n        uncommittedSegments.push(\n          this._renderSegment(featureIndex, i, points[i], points[i + 1], style)\n        );\n      }\n      if (points.length === 4) {\n        uncommittedSegments.push(this._renderSegment(featureIndex, 3, points[3], points[0], style));\n      }\n    }\n\n    if (!uncommittedLngLat) {\n      return uncommittedSegments.length ? uncommittedSegments : null;\n    }\n\n    /* eslint-disable no-inline-comments */\n    uncommittedSegments.push(\n      this._renderSegment(\n        featureIndex,\n        points.length - 1, // id\n        points.slice(-1)[0], // startPos\n        uncommittedLngLat, // endPos\n        style\n      )\n    );\n    /* eslint-enable no-inline-comments */\n\n    return uncommittedSegments.filter(Boolean);\n  };\n\n  _renderClosingStroke = (featureIndex, feature, style) => {\n    const {points, isClosed} = feature;\n    const {mode} = this.props;\n    const {uncommittedLngLat} = this.state;\n    if (uncommittedLngLat && mode === MODES.DRAW_POLYGON && points.length > 2 && !isClosed) {\n      // from uncommitted position to the first point of the polygon\n      return this._renderSegment(\n        featureIndex,\n        'uncommitted-close',\n        uncommittedLngLat,\n        points[0],\n        style\n      );\n    }\n    return null;\n  };\n\n  _renderFill = (index, feature, style) => {\n    const {mode} = this.props;\n    const isDrawing = DRAWING_MODES.find(m => m === mode);\n    const {points, renderType, isClosed} = feature;\n    if (renderType !== RENDER_TYPE.POLYGON && renderType !== RENDER_TYPE.RECTANGLE) {\n      return null;\n    }\n\n    const {uncommittedLngLat} = this.state;\n\n    let fillPoints = points;\n    if (uncommittedLngLat && isDrawing) {\n      fillPoints = [...points, uncommittedLngLat];\n    }\n\n    const fillPath = this._getProjectedData(fillPoints, renderType, isClosed);\n    return (\n      <path\n        data-type={ELEMENT_TYPE.FEATURE}\n        data-feature-index={index}\n        key={`${ELEMENT_TYPE.FEATURE}.${index}.fill`}\n        style={{...style, stroke: 'none'}}\n        d={fillPath}\n      />\n    );\n  };\n\n  _renderCurrentPath = (feature, index) => {\n    const {points, renderType} = feature;\n    if (!points || !points.length || renderType === RENDER_TYPE.POINT) {\n      return null;\n    }\n\n    const {getFeatureStyle} = this.props;\n    const geoJson = feature.toFeature();\n    const committedStyle = getFeatureStyle({feature: geoJson, state: RENDER_STATE.SELECTED});\n    const uncommittedStyle = getFeatureStyle({feature: geoJson, state: RENDER_STATE.UNCOMMITTED});\n    const closingStyle = getFeatureStyle({feature: geoJson, state: RENDER_STATE.CLOSING});\n\n    const committedStroke = this._renderCommittedStroke(index, feature, committedStyle);\n    const uncommittedStrokes =\n      this._renderUncommittedStrokes(index, feature, uncommittedStyle) || [];\n    const closingStroke = this._renderClosingStroke(index, feature, closingStyle);\n    const fill = this._renderFill(index, feature, uncommittedStyle);\n\n    return [fill, committedStroke, ...uncommittedStrokes, closingStroke].filter(Boolean);\n  };\n\n  _renderCommittedVertices = (featureIndex, feature, geoJson) => {\n    const {mode, getEditHandleStyle, getEditHandleShape} = this.props;\n    const {isClosed, points} = feature;\n\n    const committedVertices = [];\n    for (let i = 0; i < points.length; i++) {\n      const p = points[i];\n      let operation = OPERATIONS.SET;\n\n      const style = getEditHandleStyle({\n        feature: geoJson,\n        index: i,\n        state: this._getEditHandleState(i)\n      });\n      const shape =\n        typeof getEditHandleShape === 'function'\n          ? getEditHandleShape({\n              feature: geoJson,\n              index: i,\n              state: this._getEditHandleState(i)\n            })\n          : getEditHandleShape;\n\n      if (isClosed) {\n        committedVertices.push(this._renderVertex(p, featureIndex, i, operation, style, shape));\n      } else {\n        if (mode === MODES.DRAW_POLYGON && i === 0 && points.length > 2) {\n          operation = OPERATIONS.INTERSECT;\n        }\n\n        committedVertices.push(this._renderVertex(p, featureIndex, i, operation, style, shape));\n      }\n    }\n\n    return committedVertices;\n  };\n\n  _renderUncommittedVertex = (featureIndex, feature, geoJson) => {\n    const {getEditHandleStyle, getEditHandleShape} = this.props;\n    const {selectedFeatureId, uncommittedLngLat} = this.state;\n    const {id} = feature;\n\n    let uncommittedVertex = null;\n    if (selectedFeatureId === id && uncommittedLngLat) {\n      const style = getEditHandleStyle({\n        feature: geoJson,\n        index: 'uncommitted',\n        state: this._getEditHandleState(-1, RENDER_STATE.UNCOMMITTED)\n      });\n\n      const shape =\n        typeof getEditHandleShape === 'function'\n          ? getEditHandleShape({\n              feature: geoJson,\n              index: null,\n              state: this._getEditHandleState(-1)\n            })\n          : getEditHandleShape;\n\n      uncommittedVertex = this._renderVertex(\n        uncommittedLngLat,\n        featureIndex,\n        'uncommitted',\n        OPERATIONS.INSERT,\n        {...style, pointerEvents: 'none'},\n        shape\n      );\n    }\n\n    return uncommittedVertex;\n  };\n\n  _renderCurrentVertices = (feature, featureIndex) => {\n    const {points} = feature;\n\n    if (!points || !points.length) {\n      return null;\n    }\n\n    const geoJson = feature.toFeature();\n    const committedVertices = this._renderCommittedVertices(featureIndex, feature, geoJson);\n    const uncommittedVertex = this._renderUncommittedVertex(featureIndex, feature, geoJson);\n\n    return (\n      <g key=\"edit-handles\">\n        {committedVertices}\n        {uncommittedVertex}\n      </g>\n    );\n  };\n\n  _renderCurrent = () => {\n    const {features} = this.state;\n    const feature = this._getSelectedFeature();\n\n    if (!features || !feature || !feature.points) {\n      return null;\n    }\n\n    const {mode} = this.props;\n    const index = features.findIndex(f => f.id === feature.id);\n\n    return (\n      <g\n        key=\"feature current\"\n        style={mode === MODES.READ_ONLY || mode === MODES.SELECT_FEATURE ? STATIC_STYLE : null}\n      >\n        {this._renderCurrentPath(feature, index)}\n        {this._renderCurrentVertices(feature, index)}\n      </g>\n    );\n  };\n\n  _renderFeature = (feature, index) => {\n    if (feature === this._getSelectedFeature()) {\n      return null;\n    }\n\n    const {clickRadius} = this.props;\n    const {id, points, renderType, isClosed} = feature;\n    if (!points || !points.length) {\n      return null;\n    }\n\n    const projected = this._getProjectedData(points, renderType, isClosed);\n\n    if (!projected) {\n      return null;\n    }\n\n    const geoJson = feature.toFeature();\n    const renderState = this._getFeatureRenderState(id);\n    const {getFeatureStyle, getFeatureShape} = this.props;\n    const style = getFeatureStyle({feature: geoJson, state: renderState});\n    const shape =\n      typeof getFeatureShape === 'function'\n        ? getFeatureShape({feature: geoJson, state: renderState})\n        : getFeatureShape;\n\n    const elemKey = `${ELEMENT_TYPE.FEATURE}.${index}`;\n\n    switch (renderType) {\n      case RENDER_TYPE.POINT:\n        if (shape === 'rect') {\n          return (\n            <g key={elemKey} transform={`translate(${projected[0][0]}, ${projected[0][1]})`}>\n              <rect\n                data-type={ELEMENT_TYPE.FEATURE}\n                data-feature-index={index}\n                key={`${elemKey}.hidden`}\n                style={{\n                  ...style,\n                  ...HIDDEN_CLICKABLE_STYLE,\n                  width: clickRadius,\n                  height: clickRadius\n                }}\n              />\n              <rect\n                data-type={ELEMENT_TYPE.FEATURE}\n                data-feature-index={index}\n                key={elemKey}\n                style={style}\n              />\n            </g>\n          );\n        }\n\n        return (\n          <g key={elemKey} transform={`translate(${projected[0][0]}, ${projected[0][1]})`}>\n            <circle\n              data-type={ELEMENT_TYPE.FEATURE}\n              data-feature-index={index}\n              key={`${elemKey}.hidden`}\n              style={{\n                ...style,\n                opacity: 0\n              }}\n              cx={0}\n              cy={0}\n              r={clickRadius}\n            />\n            <circle\n              data-type={ELEMENT_TYPE.FEATURE}\n              data-feature-index={index}\n              key={`feature.${index}`}\n              style={style}\n              cx={0}\n              cy={0}\n            />\n          </g>\n        );\n\n      // first <path> is to make path easily interacted with\n      case RENDER_TYPE.LINE_STRING:\n        return (\n          <g key={elemKey}>\n            <path\n              data-type={ELEMENT_TYPE.FEATURE}\n              data-feature-index={index}\n              key={`${elemKey}.hidden`}\n              style={{\n                ...style,\n                strokeWidth: clickRadius,\n                opacity: 0\n              }}\n              d={projected}\n            />\n            <path\n              data-type={ELEMENT_TYPE.FEATURE}\n              data-feature-index={index}\n              key={elemKey}\n              style={style}\n              d={projected}\n            />\n          </g>\n        );\n\n      case 'Polygon':\n      case 'Rectangle':\n        return (\n          <path\n            data-type={ELEMENT_TYPE.FEATURE}\n            data-feature-index={index}\n            key={elemKey}\n            style={style}\n            d={projected}\n          />\n        );\n\n      default:\n        return null;\n    }\n  };\n\n  _renderFeatures = () => {\n    const {features} = this.state;\n    return features && features.map(this._renderFeature);\n  };\n\n  _renderCanvas = () => {\n    const {selectedFeatureId, features} = this.state;\n\n    return (\n      <svg key=\"draw-canvas\" width=\"100%\" height=\"100%\">\n        {features && features.length > 0 && <g key=\"feature-group\">{this._renderFeatures()}</g>}\n        {selectedFeatureId && this._renderCurrent()}\n      </svg>\n    );\n  };\n\n  _renderEditor = () => {\n    const viewport = (this._context && this._context.viewport) || {};\n    const {style} = this.props;\n    const {width, height} = viewport;\n\n    return (\n      <div\n        id=\"editor\"\n        style={{\n          width,\n          height,\n          ...style\n        }}\n        ref={_ => {\n          this._containerRef = _;\n        }}\n      >\n        {this._renderCanvas()}\n      </div>\n    );\n  };\n\n  render() {\n    return (\n      <MapContext.Consumer>\n        {context => {\n          this._context = context;\n          const viewport = context && context.viewport;\n\n          if (!viewport || viewport.height <= 0 || viewport.width <= 0) {\n            return null;\n          }\n\n          return this._renderEditor();\n        }}\n      </MapContext.Consumer>\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}