deeptwins-engine-3d 0.1.64 → 0.1.65

package/dist/esm/drawer/index.d.ts

@@ -1,24 +1,13 @@
-export interface DrawContext {
-    options: any;
-    getMap: any;
-    setDrawerLayer: any;
-    _changeStatus: any;
-    _updateTooltip: any;
-}
-export declare const STATUS: {
-    readonly INIT: "INIT";
-    readonly START_DRAW: "START_DRAW";
-    readonly DRAWING: "DRAWING";
-    readonly END_DRAW: "END_DRAW";
-    readonly EDITING: "EDITING";
-    readonly END_EDIT: "END_EDIT";
-};
-export type Status = (typeof STATUS)[keyof typeof STATUS];
+import type { DataTransformDrawOptions, DrawContext } from './types';
 export declare const MULTI_POINT_SHAPE_TYPES: {
     readonly POLYLINE: "polyline";
     readonly POLYGON: "polygon";
+    readonly ATTACK_ARROW: "attackArrow";
+    readonly CURVE: "curve";
+    readonly PINCER_ARROW: "pincerArrow";
+    readonly SECTOR: "sector";
 };
-export declare const MULTI_POINT_SHAPES: ("polyline" | "polygon")[];
+export declare const MULTI_POINT_SHAPES: ("polyline" | "polygon" | "attackArrow" | "curve" | "pincerArrow" | "sector")[];
 declare class Drawer implements DrawContext {
     private readonly _mapContext;
     private readonly _drawContext;
@@ -36,6 +25,7 @@ declare class Drawer implements DrawContext {
     private _instance;
     private _drawLayers;
     constructor(map: any, options?: any);
+    private _resetInteractionState;
     private _canOperate;
     getMap(): any;
     _isDragPoint(e: any): any;
@@ -43,7 +33,8 @@ declare class Drawer implements DrawContext {
     private _destroyListeners;
     _updateTooltip(): void;
     _changeStatus(status: any): void;
-    dataTransformDraw(data: any): any[] | undefined;
+    private _createRestoreLayer;
+    dataTransformDraw(data: any, options?: DataTransformDrawOptions): any[] | undefined;
     startDraw(type: any, config?: any): any;
     private _stopDraw;
     startEdit(id: any): void;
@@ -57,3 +48,5 @@ declare class Drawer implements DrawContext {
     destroy(): void;
 }
 export default Drawer;
+export { STATUS } from './types';
+export type { DataTransformDrawOptions, DrawContext, Status } from './types';

package/dist/esm/drawer/index.js

@@ -1,4 +1,6 @@
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -12,47 +14,71 @@ import { DEFAULT_DRAWER_OPTIONS, LAYER_EVENT_TYPE } from "../constant";
 import BaseSource from "../graphicLayer/BaseSource";
 import * as utils from "../tool/utils";
 import ToolTip from "../toolTip/index";
+import Assemble from "./shape/Assemble";
+import AttackArrow from "./shape/AttackArrow";
+import Bow from "./shape/Bow";
+import Circle from "./shape/Circle";
+import Curve from "./shape/Curve";
+import Elliptic from "./shape/Elliptic";
+import Formation from "./shape/Formation";
+import PincerArrow from "./shape/PincerArrow";
 import Point from "./shape/Point";
 import Polygon from "./shape/Polygon";
 import Polyline from "./shape/Polyline";
-import { HANDLE_FEATURE_DATA_TYPE_FUN } from "./utils";
+import RegularPolygon from "./shape/RegularPolygon";
+import RightAngleArrow from "./shape/RightAngleArrow";
+import Sector from "./shape/Sector";
+import StraightArrow from "./shape/StraightArrow";
+import SwallowtailArrow from "./shape/SwallowtailArrow";
+import { STATUS } from "./types";
+import { getDrawerRestoreItems, getSectorRestoreAnchors } from "./utils";
 
 // 根据类型相应的实现类
 var DYNAMIC_GRAPHICS_TYPE = {
   point: Point,
   polyline: Polyline,
-  polygon: Polygon
+  polygon: Polygon,
+  assemble: Assemble,
+  attackArrow: AttackArrow,
+  bow: Bow,
+  curve: Curve,
+  elliptic: Elliptic,
+  formation: Formation,
+  pincerArrow: PincerArrow,
+  rightAngleArrow: RightAngleArrow,
+  sector: Sector,
+  straightArrow: StraightArrow,
+  swallowtailArrow: SwallowtailArrow,
+  circle: Circle,
+  regularPolygon: RegularPolygon
 };
 
-// 根据相应的geoJson类型获取相应的实现类
-var dynamicGraphicsGeoJsonType = {
-  Point: Point,
-  MultiPoint: Point,
-  LineString: Polyline,
-  MultiLineString: Polyline,
-  Polygon: Polygon,
-  MultiPolygon: Polygon
-};
-// 状态表定义
-export var STATUS = {
-  INIT: 'INIT',
-  START_DRAW: 'START_DRAW',
-  DRAWING: 'DRAWING',
-  END_DRAW: 'END_DRAW',
-  EDITING: 'EDITING',
-  END_EDIT: 'END_EDIT'
-};
-
-// 从状态表推导类型
-
 // 支持多点绘制的形状类型表
 export var MULTI_POINT_SHAPE_TYPES = {
   POLYLINE: 'polyline',
-  POLYGON: 'polygon'
+  POLYGON: 'polygon',
+  ATTACK_ARROW: 'attackArrow',
+  CURVE: 'curve',
+  PINCER_ARROW: 'pincerArrow',
+  SECTOR: 'sector'
 };
 
 // 支持多点绘制的形状类型数组
 export var MULTI_POINT_SHAPES = Object.values(MULTI_POINT_SHAPE_TYPES);
+
+// 通过两个控制点完成绘制的形状类型。
+var TWO_POINT_SHAPE_TYPES = {
+  CIRCLE: 'circle',
+  REGULAR_POLYGON: 'regularPolygon',
+  ASSEMBLE: 'assemble',
+  BOW: 'bow',
+  ELLIPTIC: 'elliptic',
+  FORMATION: 'formation',
+  RIGHT_ANGLE_ARROW: 'rightAngleArrow',
+  STRAIGHT_ARROW: 'straightArrow',
+  SWALLOWTAIL_ARROW: 'swallowtailArrow'
+};
+var TWO_POINT_SHAPES = Object.values(TWO_POINT_SHAPE_TYPES);
 var Drawer = /*#__PURE__*/function () {
   function Drawer(map) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -89,9 +115,23 @@ var Drawer = /*#__PURE__*/function () {
       _updateTooltip: this._updateTooltip.bind(this)
     };
   }
-
-  // 是否能进行操作
   _createClass(Drawer, [{
+    key: "_resetInteractionState",
+    value: function _resetInteractionState() {
+      this._dragging = false;
+      var map = this.getMap();
+      if (!map) {
+        return;
+      }
+      if (typeof map.isDestroyed === 'function' && map.isDestroyed()) {
+        return;
+      }
+      map.canvas.style.cursor = 'default';
+      map.scene.screenSpaceCameraController.enableRotate = true;
+    }
+
+    // 是否能进行操作
+  }, {
     key: "_canOperate",
     value: function _canOperate() {
       if (this.isDestroyed) {
@@ -113,11 +153,11 @@ var Drawer = /*#__PURE__*/function () {
       var _this$_instance$dragP, _this$_instance$edges;
       // 拖拽点图层
       var dragPoint = (_this$_instance$dragP = this._instance.dragPoints) === null || _this$_instance$dragP === void 0 ? void 0 : _this$_instance$dragP.find(function (point) {
-        var _e$pickedObject;
-        return point.layer.layers[0].id === (e === null || e === void 0 || (_e$pickedObject = e.pickedObject) === null || _e$pickedObject === void 0 || (_e$pickedObject = _e$pickedObject.id) === null || _e$pickedObject === void 0 ? void 0 : _e$pickedObject.id);
+        var _point$layer, _e$pickedObject;
+        return ((_point$layer = point.layer) === null || _point$layer === void 0 || (_point$layer = _point$layer.layers) === null || _point$layer === void 0 || (_point$layer = _point$layer[0]) === null || _point$layer === void 0 ? void 0 : _point$layer.id) === (e === null || e === void 0 || (_e$pickedObject = e.pickedObject) === null || _e$pickedObject === void 0 || (_e$pickedObject = _e$pickedObject.id) === null || _e$pickedObject === void 0 ? void 0 : _e$pickedObject.id);
       });
       // 中间点图层
-      var middlePoint = (_this$_instance$edges = this._instance.edges.find(function (t) {
+      var middlePoint = (_this$_instance$edges = this._instance.edges) === null || _this$_instance$edges === void 0 || (_this$_instance$edges = _this$_instance$edges.find(function (t) {
         var _t$middlePoint, _e$pickedObject2;
         return (t === null || t === void 0 || (_t$middlePoint = t.middlePoint) === null || _t$middlePoint === void 0 || (_t$middlePoint = _t$middlePoint.layer) === null || _t$middlePoint === void 0 || (_t$middlePoint = _t$middlePoint.layers) === null || _t$middlePoint === void 0 || (_t$middlePoint = _t$middlePoint[0]) === null || _t$middlePoint === void 0 ? void 0 : _t$middlePoint.id) === (e === null || e === void 0 || (_e$pickedObject2 = e.pickedObject) === null || _e$pickedObject2 === void 0 || (_e$pickedObject2 = _e$pickedObject2.id) === null || _e$pickedObject2 === void 0 ? void 0 : _e$pickedObject2.id);
       })) === null || _this$_instance$edges === void 0 ? void 0 : _this$_instance$edges.middlePoint;
@@ -145,9 +185,8 @@ var Drawer = /*#__PURE__*/function () {
       this._eventLeftUp = this.getMap().on(LAYER_EVENT_TYPE.LEFT_UP, function (e) {
         if (!_this._instance) return;
         if (_this._dragging) {
-          _this._dragging = false;
           _this._instance.mouseDragEnd(e.position);
-          _this.getMap().scene.screenSpaceCameraController.enableRotate = true;
+          _this._resetInteractionState();
         }
       });
       // 鼠标点击
@@ -162,7 +201,7 @@ var Drawer = /*#__PURE__*/function () {
         if (!_this._instance) return;
         // 绘制
         if (_this._status === STATUS.START_DRAW || _this._status === STATUS.DRAWING) {
-          if (MULTI_POINT_SHAPES.includes(_this._instance.type)) {
+          if (MULTI_POINT_SHAPES.includes(_this._instance.type) || TWO_POINT_SHAPES.includes(_this._instance.type)) {
             _this._instance.updateTempPosition(e.position);
           }
         }
@@ -221,13 +260,17 @@ var Drawer = /*#__PURE__*/function () {
     value: function _updateTooltip() {
       if (!this._canOperate()) return;
       if (this._status === STATUS.START_DRAW) {
+        var _this$_instance;
+        var shapeType = (_this$_instance = this._instance) === null || _this$_instance === void 0 ? void 0 : _this$_instance.type;
         this.tooltip.setOptions({
-          text: '点击开始绘制'
+          text: shapeType === 'circle' || shapeType === 'regularPolygon' || shapeType === 'elliptic' ? '点击确定中心点' : shapeType === 'assemble' || shapeType === 'bow' || shapeType === 'formation' || shapeType === 'rightAngleArrow' || shapeType === 'straightArrow' || shapeType === 'swallowtailArrow' ? '点击确定起点' : '点击开始绘制'
         });
         this.tooltip.show(true);
       } else if (this._status === STATUS.DRAWING) {
+        var _this$_instance2;
+        var _shapeType = (_this$_instance2 = this._instance) === null || _this$_instance2 === void 0 ? void 0 : _this$_instance2.type;
         this.tooltip.setOptions({
-          text: '左键添加点，右键移除点，双击结束绘制'
+          text: _shapeType === 'circle' || _shapeType === 'regularPolygon' ? '移动鼠标调整半径，左键完成绘制' : _shapeType === 'elliptic' ? '移动鼠标调整长轴，左键完成绘制' : _shapeType === 'assemble' ? '移动鼠标调整集结地形状，左键完成绘制' : _shapeType === 'bow' ? '移动鼠标调整弓形，左键完成绘制' : _shapeType === 'formation' ? '移动鼠标调整阵型，左键完成绘制' : _shapeType === 'rightAngleArrow' ? '移动鼠标调整直角箭头，左键完成绘制' : _shapeType === 'straightArrow' ? '移动鼠标调整直线箭头，左键完成绘制' : _shapeType === 'swallowtailArrow' ? '移动鼠标调整燕尾箭头，左键完成绘制' : '左键添加点，右键移除点，双击结束绘制'
         });
       } else {
         this.tooltip.show(false);
@@ -240,12 +283,176 @@ var Drawer = /*#__PURE__*/function () {
     value: function _changeStatus(status) {
       this._status = status;
     }
+  }, {
+    key: "_createRestoreLayer",
+    value: function _createRestoreLayer(shapeType, positions) {
+      var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var restoreConfig = config;
+      if (shapeType === 'circle') {
+        var hasCenter = Array.isArray(config === null || config === void 0 ? void 0 : config.center) && config.center.length >= 2;
+        if (!hasCenter) {
+          utils.warn('还原circle时必须显式传入center，当前已回退为普通polygon');
+          var _fallbackLayer = new Polygon(this._drawContext, config);
+          _fallbackLayer.transformData(positions);
+          return _fallbackLayer;
+        }
+      }
+      if (shapeType === 'regularPolygon') {
+        var restoreSides = Number(config === null || config === void 0 ? void 0 : config.sides);
+        var _hasCenter = Array.isArray(config === null || config === void 0 ? void 0 : config.center) && config.center.length >= 2;
+        if (!_hasCenter || !Number.isFinite(restoreSides)) {
+          utils.warn('还原regularPolygon时必须显式传入center和sides，当前已回退为普通polygon');
+          var _fallbackLayer2 = new Polygon(this._drawContext, config);
+          _fallbackLayer2.transformData(positions);
+          return _fallbackLayer2;
+        }
+      }
+      if (shapeType === 'assemble') {
+        var anchors = config === null || config === void 0 ? void 0 : config.anchors;
+        var hasAnchors = Array.isArray(anchors) && anchors.length >= 2 && anchors[0] && anchors[1];
+        if (!hasAnchors) {
+          utils.warn('还原assemble时必须显式传入anchors(>=2)，当前已回退为普通polygon');
+          var _fallbackLayer3 = new Polygon(this._drawContext, config);
+          _fallbackLayer3.transformData(positions);
+          return _fallbackLayer3;
+        }
+      }
+      if (shapeType === 'attackArrow') {
+        var _anchors = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors = Array.isArray(_anchors) && _anchors.length >= 3;
+        if (!_hasAnchors) {
+          utils.warn('还原attackArrow时必须显式传入anchors(>=3)，当前已回退为普通polygon');
+          var _fallbackLayer4 = new Polygon(this._drawContext, config);
+          _fallbackLayer4.transformData(positions);
+          return _fallbackLayer4;
+        }
+      }
+      if (shapeType === 'pincerArrow') {
+        var _anchors2 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors2 = Array.isArray(_anchors2) && _anchors2.length >= 3;
+        if (!_hasAnchors2) {
+          utils.warn('还原pincerArrow时必须显式传入anchors(>=3)，当前已回退为普通polygon');
+          var _fallbackLayer5 = new Polygon(this._drawContext, config);
+          _fallbackLayer5.transformData(positions);
+          return _fallbackLayer5;
+        }
+      }
+      if (shapeType === 'bow') {
+        var _anchors3 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors3 = Array.isArray(_anchors3) && _anchors3.length >= 2 && _anchors3[0] && _anchors3[1];
+        if (!_hasAnchors3) {
+          utils.warn('还原bow时必须显式传入anchors(>=2)，当前已回退为普通polyline');
+          var _fallbackLayer6 = new Polyline(this._drawContext, config);
+          _fallbackLayer6.transformData(positions);
+          return _fallbackLayer6;
+        }
+      }
+      if (shapeType === 'curve') {
+        var _anchors4 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors4 = Array.isArray(_anchors4) && _anchors4.length >= 2;
+        if (!_hasAnchors4) {
+          utils.warn('还原curve时必须显式传入anchors(>=2)，当前已回退为普通polyline');
+          var _fallbackLayer7 = new Polyline(this._drawContext, config);
+          _fallbackLayer7.transformData(positions);
+          return _fallbackLayer7;
+        }
+      }
+      if (shapeType === 'elliptic') {
+        var _anchors5 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors5 = Array.isArray(_anchors5) && _anchors5.length >= 2;
+        if (!_hasAnchors5) {
+          utils.warn('还原elliptic时必须显式传入anchors(>=2)，当前已回退为普通polygon');
+          var _fallbackLayer8 = new Polygon(this._drawContext, config);
+          _fallbackLayer8.transformData(positions);
+          return _fallbackLayer8;
+        }
+      }
+      if (shapeType === 'rightAngleArrow') {
+        var _anchors6 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors6 = Array.isArray(_anchors6) && _anchors6.length >= 2 && _anchors6[0] && _anchors6[1];
+        if (!_hasAnchors6) {
+          utils.warn('还原rightAngleArrow时必须显式传入anchors(>=2)，当前已回退为普通polygon');
+          var _fallbackLayer9 = new Polygon(this._drawContext, config);
+          _fallbackLayer9.transformData(positions);
+          return _fallbackLayer9;
+        }
+      }
+      if (shapeType === 'sector') {
+        var _restoreConfig;
+        var _anchors7 = (_restoreConfig = restoreConfig) === null || _restoreConfig === void 0 ? void 0 : _restoreConfig.anchors;
+        var _hasAnchors7 = Array.isArray(_anchors7) && _anchors7.length >= 3;
+        if (!_hasAnchors7) {
+          var inferredAnchors = getSectorRestoreAnchors(positions);
+          if (inferredAnchors) {
+            restoreConfig = _objectSpread(_objectSpread({}, restoreConfig), {}, {
+              anchors: inferredAnchors
+            });
+          } else {
+            utils.warn('还原sector时无法从已有 polygon 自动推导 anchors(>=3)，当前已回退为普通polygon');
+            var _fallbackLayer10 = new Polygon(this._drawContext, restoreConfig);
+            _fallbackLayer10.transformData(positions);
+            return _fallbackLayer10;
+          }
+        }
+      }
+      if (shapeType === 'straightArrow') {
+        var _anchors8 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors8 = Array.isArray(_anchors8) && _anchors8.length >= 2 && _anchors8[0] && _anchors8[1];
+        if (!_hasAnchors8) {
+          utils.warn('还原straightArrow时必须显式传入anchors(>=2)，当前已回退为普通polygon');
+          var _fallbackLayer11 = new Polygon(this._drawContext, config);
+          _fallbackLayer11.transformData(positions);
+          return _fallbackLayer11;
+        }
+      }
+      if (shapeType === 'swallowtailArrow') {
+        var _anchors9 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors9 = Array.isArray(_anchors9) && _anchors9.length >= 2 && _anchors9[0] && _anchors9[1];
+        if (!_hasAnchors9) {
+          utils.warn('还原swallowtailArrow时必须显式传入anchors(>=2)，当前已回退为普通polygon');
+          var _fallbackLayer12 = new Polygon(this._drawContext, config);
+          _fallbackLayer12.transformData(positions);
+          return _fallbackLayer12;
+        }
+      }
+      if (shapeType === 'formation') {
+        var _anchors10 = config === null || config === void 0 ? void 0 : config.anchors;
+        var _hasAnchors10 = Array.isArray(_anchors10) && _anchors10.length >= 2;
+        if (!_hasAnchors10) {
+          utils.warn('还原formation时必须显式传入anchors(>=2)，当前已回退为普通polyline');
+          var _fallbackLayer13 = new Polyline(this._drawContext, config);
+          _fallbackLayer13.transformData(positions);
+          return _fallbackLayer13;
+        }
+      }
+      var shapeClass = DYNAMIC_GRAPHICS_TYPE[shapeType];
+      if (!shapeClass) {
+        return;
+      }
+      var layer = new shapeClass(this._drawContext, restoreConfig);
+      var transformResult = layer.transformData(positions, restoreConfig);
+      if (transformResult !== false) {
+        return layer;
+      }
+      if (shapeType !== 'circle' && shapeType !== 'regularPolygon' && shapeType !== 'assemble' && shapeType !== 'attackArrow' && shapeType !== 'bow' && shapeType !== 'curve' && shapeType !== 'elliptic' && shapeType !== 'pincerArrow' && shapeType !== 'rightAngleArrow' && shapeType !== 'sector' && shapeType !== 'straightArrow' && shapeType !== 'swallowtailArrow' && shapeType !== 'formation') {
+        return;
+      }
+      if (shapeType === 'bow' || shapeType === 'curve' || shapeType === 'formation') {
+        var _fallbackLayer14 = new Polyline(this._drawContext, restoreConfig);
+        _fallbackLayer14.transformData(positions);
+        return _fallbackLayer14;
+      }
+      var fallbackLayer = new Polygon(this._drawContext, restoreConfig);
+      fallbackLayer.transformData(positions);
+      return fallbackLayer;
+    }
 
     // 转化为绘制类型
   }, {
     key: "dataTransformDraw",
     value: function dataTransformDraw(data) {
       var _this2 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var dataType = BaseSource.analysisSourceType(data);
       var transformGeoJson;
       if (dataType === 'wkt') {
@@ -256,24 +463,11 @@ var Drawer = /*#__PURE__*/function () {
       if (!transformGeoJson) return;
       var layers = [];
       featureEach(transformGeoJson, function (feature) {
-        var handle = HANDLE_FEATURE_DATA_TYPE_FUN[feature.geometry.type];
-        var shapeClass = dynamicGraphicsGeoJsonType[feature.geometry.type];
-        if (!shapeClass) return;
-        if (handle) {
-          var handleFeature = handle(feature);
-          if (handleFeature.type === 'single') {
-            var layer = new shapeClass(_this2._drawContext);
-            layer.transformData(handleFeature.positions);
-            layers.push(layer);
-          }
-          if (handleFeature.type === 'multi') {
-            handleFeature.positions.forEach(function (position) {
-              var layer = new shapeClass(_this2._drawContext);
-              layer.transformData(position);
-              layers.push(layer);
-            });
-          }
-        }
+        var restoreItems = getDrawerRestoreItems(feature, options);
+        restoreItems.forEach(function (item) {
+          var layer = _this2._createRestoreLayer(item.shapeType, item.positions, item.config);
+          layer && layers.push(layer);
+        });
       });
       return layers;
     }
@@ -284,14 +478,14 @@ var Drawer = /*#__PURE__*/function () {
     value: function startDraw(type) {
       var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       if (!this._canOperate()) return;
+      var shapeClass = DYNAMIC_GRAPHICS_TYPE[type];
+      if (!shapeClass) return;
       if (this._instance) {
         this._stopDraw();
       }
       this._changeStatus(STATUS.START_DRAW);
       this.getMap().canvas.style.cursor = 'crosshair';
       this._updateTooltip();
-      var shapeClass = DYNAMIC_GRAPHICS_TYPE[type];
-      if (!shapeClass) return;
       this._instance = new shapeClass(this._drawContext, config);
       return this._instance;
     }
@@ -303,21 +497,28 @@ var Drawer = /*#__PURE__*/function () {
       if (!this._canOperate()) return;
       if (!this._instance) return;
       if (this._status === STATUS.INIT || this._status === STATUS.START_DRAW || this._status === STATUS.END_EDIT) {
-        var layer = this.getDrawerLayer(this._instance);
+        var layer = this._drawLayers.get(this._instance.id);
         // layer未存入
         if (!layer) {
           this._instance.destroy();
         }
+        this._resetInteractionState();
+        this._changeStatus(STATUS.INIT);
+        this._updateTooltip();
         this._instance = null;
         return;
       }
       if (this._status === STATUS.DRAWING) {
         this.removeDrawerLayer(this._instance);
-        this._instance = null;
         return;
       }
       if (this._status === STATUS.END_DRAW || this._status === STATUS.EDITING) {
-        this.endEdit();
+        this._resetInteractionState();
+        this._instance.endEdit(this._instance, false);
+        this.setDrawerLayer(this._instance.id, this._instance);
+        this._instance = null;
+        this._changeStatus(STATUS.INIT);
+        this._updateTooltip();
         return;
       }
     }
@@ -329,13 +530,20 @@ var Drawer = /*#__PURE__*/function () {
       if (!this._canOperate()) return;
       if (!id) return;
       if (this._instance) {
-        this._instance.endEdit(this._instance);
-        this.setDrawerLayer(this._instance.id, this._instance);
-        this._instance = null;
+        if (this._status === STATUS.EDITING || this._status === STATUS.END_DRAW) {
+          this._resetInteractionState();
+          this._instance.endEdit(this._instance, false);
+          this.setDrawerLayer(this._instance.id, this._instance);
+          this._instance = null;
+        } else {
+          this._stopDraw();
+        }
       }
+      var layer = this.getDrawerLayer(id);
+      if (!layer) return;
+      this._instance = layer;
       this._changeStatus(STATUS.EDITING);
-      this._instance = this.getDrawerLayer(id);
-      if (!this._instance) return;
+      this._updateTooltip();
       this._instance.startEdit();
     }
 
@@ -344,7 +552,7 @@ var Drawer = /*#__PURE__*/function () {
     key: "endEdit",
     value: function endEdit() {
       if (!this._canOperate()) return;
-      this.getMap().canvas.style.cursor = 'default';
+      this._resetInteractionState();
       this._changeStatus(STATUS.END_EDIT);
       this._updateTooltip();
       if (!this._instance) return;
@@ -357,16 +565,20 @@ var Drawer = /*#__PURE__*/function () {
   }, {
     key: "getDrawerLayer",
     value: function getDrawerLayer(id) {
-      if (!this._canOperate) return;
+      if (!this._canOperate()) return;
       if (!id) return;
-      return isString(id) ? this._drawLayers.get(id) : id;
+      if (isString(id)) {
+        return this._drawLayers.get(id);
+      }
+      return id && _typeof(id) === 'object' && 'id' in id ? id : undefined;
     }
 
     // 添加完成绘制的图层
   }, {
     key: "setDrawerLayer",
     value: function setDrawerLayer(id, value) {
-      if (!this._instance) return;
+      if (!this._canOperate()) return;
+      if (!id || !value) return;
       this._drawLayers.set(id, value);
     }
 
@@ -374,14 +586,14 @@ var Drawer = /*#__PURE__*/function () {
   }, {
     key: "removeDrawerLayer",
     value: function removeDrawerLayer(id) {
-      if (!this._canOperate) return;
+      if (!this._canOperate()) return;
       var layer = this.getDrawerLayer(id);
       if (layer) {
-        var _this$_instance;
-        if (layer.id === (this === null || this === void 0 || (_this$_instance = this._instance) === null || _this$_instance === void 0 ? void 0 : _this$_instance.id)) {
+        var _this$_instance3;
+        if (layer.id === (this === null || this === void 0 || (_this$_instance3 = this._instance) === null || _this$_instance3 === void 0 ? void 0 : _this$_instance3.id)) {
+          this._resetInteractionState();
           this._instance = null;
-          this._status = STATUS.INIT;
-          this.getMap().canvas.style.cursor = 'default';
+          this._changeStatus(STATUS.INIT);
           this._updateTooltip();
         }
         this._drawLayers.delete(layer.id);
@@ -394,7 +606,7 @@ var Drawer = /*#__PURE__*/function () {
   }, {
     key: "getAllDrawerLayers",
     value: function getAllDrawerLayers() {
-      if (!this._canOperate) return;
+      if (!this._canOperate()) return;
       return Array.from(this._drawLayers.values());
     }
 
@@ -402,22 +614,36 @@ var Drawer = /*#__PURE__*/function () {
   }, {
     key: "clearAllDrawerLayers",
     value: function clearAllDrawerLayers() {
-      if (!this._canOperate) return;
-      this._drawLayers.forEach(function (t) {
+      var _this3 = this;
+      if (!this._canOperate()) return;
+      var layers = Array.from(new Set(this._drawLayers.values()));
+      this._drawLayers.clear();
+      layers.forEach(function (t) {
         return t.destroy();
       });
-      this._drawLayers.clear();
+      if (this._instance && !layers.some(function (layer) {
+        return layer.id === _this3._instance.id;
+      })) {
+        return;
+      }
+      this._resetInteractionState();
+      this._instance = null;
+      this._changeStatus(STATUS.INIT);
+      this._updateTooltip();
     }
 
     // 清除
   }, {
     key: "clear",
     value: function clear() {
-      if (!this._canOperate) return;
-      this.getMap().canvas.style.cursor = 'default';
+      if (!this._canOperate()) return;
+      this._resetInteractionState();
       this._changeStatus(STATUS.INIT);
       this._updateTooltip();
-      this._instance && this._instance.destroy();
+      if (this._instance) {
+        this._drawLayers.delete(this._instance.id);
+        this._instance.destroy();
+      }
       this._instance = null;
       this.clearAllDrawerLayers();
     }
@@ -426,7 +652,7 @@ var Drawer = /*#__PURE__*/function () {
   }, {
     key: "destroy",
     value: function destroy() {
-      if (!this._canOperate) return;
+      if (!this._canOperate()) return;
       this._destroyListeners();
       this.clear();
       this.tooltip.destroy();
@@ -436,4 +662,27 @@ var Drawer = /*#__PURE__*/function () {
   }]);
   return Drawer;
 }();
-export default Drawer;
+var getDrawerDrawingTooltipText = function getDrawerDrawingTooltipText(instance) {
+  if ((instance === null || instance === void 0 ? void 0 : instance.type) !== 'sector') {
+    return '左键添加点，右键移除点，双击结束绘制';
+  }
+  var anchorPositions = Array.isArray(instance === null || instance === void 0 ? void 0 : instance._anchorPositions) ? instance._anchorPositions : [];
+  return anchorPositions.length >= 2 ? '左键确定终止方向并结束绘制' : '左键确定半径';
+};
+Drawer.prototype._updateTooltip = function () {
+  if (!this._canOperate()) return;
+  if (this._status === STATUS.START_DRAW) {
+    this.tooltip.setOptions({
+      text: '点击开始绘制'
+    });
+    this.tooltip.show(true);
+  } else if (this._status === STATUS.DRAWING) {
+    this.tooltip.setOptions({
+      text: getDrawerDrawingTooltipText(this._instance)
+    });
+  } else {
+    this.tooltip.show(false);
+  }
+};
+export default Drawer;
+export { STATUS } from "./types";

package/dist/esm/{plot/utils → drawer}/plotUtil.js

@@ -1,9 +1,7 @@
 /**
  * 绘制方法
  */
-var P = {
-  version: '1.0.0'
-};
+var P = {};
 P.Constants = {
   TWO_PI: 2 * Math.PI,
   HALF_PI: Math.PI / 2,