deeptwins-engine-3d 0.1.63 → 0.1.65

package/dist/esm/drawer/shape/Curve.js

@@ -0,0 +1,386 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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 _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; }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as Cesium from 'deeptwins-cesium';
+import { isNil } from 'lodash';
+import { createBezierPoints } from "../common";
+import * as utils from "../../tool/utils";
+import { STATUS } from "../types";
+import BaseShape from "./BaseShape";
+import DragPoint from "./DragPoint";
+import { ShapePolyline } from "./Polyline";
+// 曲线至少需要 2 个控制点才能形成有效线段。
+var MIN_CURVE_ANCHORS = 2;
+var Curve = /*#__PURE__*/function (_BaseShape) {
+  _inherits(Curve, _BaseShape);
+  var _super = _createSuper(Curve);
+  function Curve(drawContext, config) {
+    var _this;
+    _classCallCheck(this, Curve);
+    _this = _super.call(this, drawContext);
+    _defineProperty(_assertThisInitialized(_this), "type", 'curve');
+    _defineProperty(_assertThisInitialized(_this), "shapePolylineLayer", void 0);
+    // 用户点击的控制点（用于编辑/还原），不同于 this.positions（渲染用特征点）。
+    _defineProperty(_assertThisInitialized(_this), "_anchorPositions", void 0);
+    // 绘制阶段用于预览的临时控制点（鼠标移动点）。
+    _defineProperty(_assertThisInitialized(_this), "_tempPosition", void 0);
+    _this._anchorPositions = [];
+    _this._tempPosition = null;
+    _this.clampToGround = isNil(config === null || config === void 0 ? void 0 : config.clampToGround) ? _this.clampToGround : config.clampToGround;
+    _this.pointStyle.heightReference = _this.clampToGround ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE;
+    _this.polylineStyle.clampToGround = _this.clampToGround;
+    return _this;
+  }
+
+  // 鼠标事件位置统一转成内部经纬高三元组。
+  _createClass(Curve, [{
+    key: "_toPositionTuple",
+    value: function _toPositionTuple(position) {
+      var lng = position.lng,
+        lat = position.lat,
+        _position$alt = position.alt,
+        alt = _position$alt === void 0 ? 0 : _position$alt;
+      return [lng, lat, alt];
+    }
+
+    // 贴地时高度统一为 0；非贴地时用控制点平均高度近似。
+  }, {
+    key: "_getAltitudeBase",
+    value: function _getAltitudeBase(anchorPositions) {
+      if (this.clampToGround) {
+        return 0;
+      }
+      var altitudes = anchorPositions.map(function (position) {
+        return position === null || position === void 0 ? void 0 : position[2];
+      }).filter(function (altitude) {
+        return Number.isFinite(altitude);
+      });
+      if (!altitudes.length) {
+        return 0;
+      }
+      return altitudes.reduce(function (sum, altitude) {
+        return sum + altitude;
+      }, 0) / altitudes.length;
+    }
+
+    // 统一释放线图层，避免绘制中断后残留几何。
+  }, {
+    key: "_destroyShapeLayer",
+    value: function _destroyShapeLayer() {
+      this.shapePolylineLayer && this.shapePolylineLayer.destroy();
+      this.shapePolylineLayer = null;
+    }
+
+    // 根据当前点数组同步线图层。
+  }, {
+    key: "_syncShapeLayer",
+    value: function _syncShapeLayer() {
+      if (!this.positions.length) {
+        this._destroyShapeLayer();
+        return;
+      }
+      if (!this.shapePolylineLayer) {
+        this.shapePolylineLayer = new ShapePolyline(this.getMap(), {
+          positions: this.positions,
+          style: this.polylineStyle
+        });
+        return;
+      }
+      this.shapePolylineLayer.update(this.positions);
+    }
+
+    // 参考 drawer/common.createBezierPoints：用控制点计算贝塞尔曲线点集。
+  }, {
+    key: "_buildCurvePositions",
+    value: function _buildCurvePositions(anchorPositions) {
+      var _this2 = this;
+      if (anchorPositions.length < MIN_CURVE_ANCHORS) {
+        return anchorPositions.length ? [anchorPositions[0]] : [];
+      }
+      var anchorCartesians = anchorPositions.map(function (position) {
+        return _this2._toCartesian3(position);
+      }).filter(function (position) {
+        return Boolean(position);
+      });
+      if (anchorCartesians.length < MIN_CURVE_ANCHORS) {
+        return [];
+      }
+      var curvePoints;
+      try {
+        curvePoints = createBezierPoints(anchorCartesians);
+      } catch (error) {
+        return [];
+      }
+      if (!Array.isArray(curvePoints) || !curvePoints.length) {
+        return [];
+      }
+      var altitudeBase = this._getAltitudeBase(anchorPositions);
+      return curvePoints.map(function (cartesian) {
+        if (!cartesian || _typeof(cartesian) !== 'object' || !Number.isFinite(cartesian.x) || !Number.isFinite(cartesian.y) || !Number.isFinite(cartesian.z)) {
+          return null;
+        }
+        var _utils$cartesian3ToLn = utils.cartesian3ToLngLatAlt(cartesian),
+          lng = _utils$cartesian3ToLn.lng,
+          lat = _utils$cartesian3ToLn.lat;
+        return [lng, lat, altitudeBase];
+      }).filter(function (position) {
+        return Boolean(position);
+      });
+    }
+
+    // 统一根据控制点更新曲线点集、渲染图层。
+  }, {
+    key: "_applyGeometry",
+    value: function _applyGeometry(anchorPositions) {
+      var positions = this._buildCurvePositions(anchorPositions);
+      if (positions.length < 2) {
+        this.positions = positions;
+        this._syncShapeLayer();
+        return positions.length > 0;
+      }
+      this.positions = positions;
+      this._syncShapeLayer();
+      return true;
+    }
+
+    // 绘制预览阶段透出当前曲线点集。
+  }, {
+    key: "_emitMouseMoveChange",
+    value: function _emitMouseMoveChange() {
+      this._drawContext.options.onMouseMoveChange && this._drawContext.options.onMouseMoveChange({
+        layer: this,
+        positions: this.positions
+      });
+    }
+
+    // 编辑态拖拽时透出最新曲线点集。
+  }, {
+    key: "_emitPointsChange",
+    value: function _emitPointsChange() {
+      var _this$_drawContext$op, _this$_drawContext$op2;
+      ((_this$_drawContext$op = this._drawContext.options) === null || _this$_drawContext$op === void 0 ? void 0 : _this$_drawContext$op.onPointsChange) && ((_this$_drawContext$op2 = this._drawContext.options) === null || _this$_drawContext$op2 === void 0 ? void 0 : _this$_drawContext$op2.onPointsChange({
+        layer: this,
+        positions: this.positions
+      }));
+    }
+
+    // 统一完成绘制：入库、触发回调并进入编辑态。
+  }, {
+    key: "_finishDraw",
+    value: function _finishDraw() {
+      if (this._anchorPositions.length < MIN_CURVE_ANCHORS) {
+        return;
+      }
+      this._drawContext.setDrawerLayer(this.id, this);
+      this.drawEnd(this);
+      this.startEdit();
+    }
+
+    // 基于 anchors 还原曲线；缺少 anchors 时由 Drawer 回退为普通 polyline。
+  }, {
+    key: "transformData",
+    value: function transformData(_) {
+      var _this3 = this;
+      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var anchors = config === null || config === void 0 ? void 0 : config.anchors;
+      if (!Array.isArray(anchors) || anchors.length < MIN_CURVE_ANCHORS) {
+        return false;
+      }
+      this._anchorPositions = anchors.filter(function (position) {
+        return Array.isArray(position) && position.length >= 2;
+      }).map(function (position) {
+        var _position = _slicedToArray(position, 3),
+          lng = _position[0],
+          lat = _position[1],
+          _position$ = _position[2],
+          alt = _position$ === void 0 ? 0 : _position$;
+        return [lng, lat, alt];
+      });
+      if (this._anchorPositions.length < MIN_CURVE_ANCHORS) {
+        return false;
+      }
+      if (!this._applyGeometry(this._anchorPositions)) {
+        return false;
+      }
+      this.dragPoints.forEach(function (point) {
+        return point.destroy();
+      });
+      this.dragPoints = [];
+      this._destroyMiddlePoints();
+      this._tempPosition = null;
+      this._anchorPositions.forEach(function (anchor, index) {
+        var point = new DragPoint(_this3.getMap(), {
+          positions: anchor,
+          style: _this3.pointStyle
+        });
+        point.isStart = index === 0;
+        point.endEdit();
+        point.show(false);
+        _this3.dragPoints.push(point);
+      });
+      this._drawContext.setDrawerLayer(this.id, this);
+      return true;
+    }
+
+    // 添加控制点；当控制点数满足算法要求时刷新曲线点集并渲染。
+  }, {
+    key: "addPoint",
+    value: function addPoint(position) {
+      var nextPosition = this._toPositionTuple(position);
+      this._anchorPositions.push(nextPosition);
+      this._tempPosition = null;
+      var point = new DragPoint(this.getMap(), {
+        positions: nextPosition,
+        style: this.pointStyle
+      });
+      point.isStart = this._anchorPositions.length === 1;
+      this.dragPoints.push(point);
+      this._applyGeometry(this._anchorPositions);
+      this.drawing(this);
+    }
+
+    // 删除上一个控制点（绘制阶段右键撤销）。
+  }, {
+    key: "removePrev",
+    value: function removePrev() {
+      if (!this._anchorPositions.length) {
+        return;
+      }
+      var removeIndex = this._anchorPositions.length - 1;
+      this._anchorPositions.splice(removeIndex, 1);
+      if (this.dragPoints[removeIndex]) {
+        this.dragPoints[removeIndex].destroy();
+        this.dragPoints.splice(removeIndex, 1);
+      }
+      if (!this._anchorPositions.length) {
+        this.positions = [];
+        this._destroyShapeLayer();
+      } else {
+        var previewAnchors = this._tempPosition ? [].concat(_toConsumableArray(this._anchorPositions), [this._tempPosition]) : _toConsumableArray(this._anchorPositions);
+        this._applyGeometry(previewAnchors);
+      }
+      this.drawing(this);
+      this._emitMouseMoveChange();
+      if (!this._anchorPositions.length) {
+        this._drawContext._changeStatus(STATUS.START_DRAW);
+        this._drawContext._updateTooltip();
+      }
+    }
+
+    // 更新临时控制点（绘制阶段鼠标移动预览）。
+  }, {
+    key: "updateTempPosition",
+    value: function updateTempPosition(position) {
+      if (!this._anchorPositions.length) {
+        return;
+      }
+      var nextPosition = this._toPositionTuple(position);
+      this._tempPosition = nextPosition;
+      var previewAnchors = [].concat(_toConsumableArray(this._anchorPositions), [nextPosition]);
+      if (!this._applyGeometry(previewAnchors)) {
+        return;
+      }
+      this._emitMouseMoveChange();
+    }
+
+    // 结束绘制：收敛曲线点集并进入编辑态。
+  }, {
+    key: "endDraw",
+    value: function endDraw() {
+      if (this._anchorPositions.length < MIN_CURVE_ANCHORS) {
+        return;
+      }
+      this._tempPosition = null;
+      if (!this._applyGeometry(this._anchorPositions)) {
+        return;
+      }
+      this._finishDraw();
+    }
+
+    // 开始编辑：沿用 Drawer 的多点编辑模式（端点+中间点插入）。
+  }, {
+    key: "startEdit",
+    value: function startEdit() {
+      if (this._anchorPositions.length < MIN_CURVE_ANCHORS) {
+        return;
+      }
+      _get(_getPrototypeOf(Curve.prototype), "startEdit", this).call(this);
+      this._startEdgeEditing();
+    }
+
+    // 开始鼠标拖拽。
+  }, {
+    key: "mouseDragStart",
+    value: function mouseDragStart(position, dragLayer) {
+      this._handleDragStart(dragLayer);
+    }
+
+    // 鼠标拖拽：更新控制点并重新计算曲线点集。
+  }, {
+    key: "mouseDragChange",
+    value: function mouseDragChange(position) {
+      if (!this.dragging || !this.dragLayer) {
+        return;
+      }
+      this.dragLayer.mouseDragChange(position);
+      var anchorPositions = this._updatePositionsFromEdges();
+      if (!anchorPositions.length) {
+        return;
+      }
+      this._anchorPositions = anchorPositions;
+      this._applyGeometry(this._anchorPositions);
+      this._emitPointsChange();
+    }
+
+    // 拖拽结束：补齐新的中间点。
+  }, {
+    key: "mouseDragEnd",
+    value: function mouseDragEnd() {
+      this._handleDragEnd();
+    }
+
+    // 结束编辑：隐藏控制点并销毁中间点。
+  }, {
+    key: "endEdit",
+    value: function endEdit(layer) {
+      var emitComplete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      _get(_getPrototypeOf(Curve.prototype), "endEdit", this).call(this, layer, emitComplete);
+      this._stopEdgeEditing();
+    }
+
+    // 销毁时同时清理渲染图层和内部几何状态。
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _get(_getPrototypeOf(Curve.prototype), "destroy", this).call(this);
+      this._destroyShapeLayer();
+      this._anchorPositions = [];
+      this._tempPosition = null;
+    }
+  }]);
+  return Curve;
+}(BaseShape);
+export default Curve;

package/dist/esm/drawer/shape/DragPoint.d.ts

@@ -0,0 +1,32 @@
+declare class DragPoint {
+    private readonly _mapContext;
+    id: string;
+    layer: any;
+    isEditing: boolean;
+    isMiddlePoint: boolean;
+    isDestroyed: boolean;
+    labelLayer: any;
+    private _geoJson;
+    private _style;
+    /**
+     * 构造函数，用于创建一个地图元素实例
+     * @param map 地图对象，包含地图上下文信息
+     * @param options 配置选项对象
+     * @param options.positions 点的坐标位置数组
+     * @param options.style 样式配置
+     * @param options.isMiddlePoint 是否为中间点的标识，默认为false
+     */
+    constructor(map: any, { positions, style, isMiddlePoint }: any);
+    getMap(): any;
+    getPosition(): any;
+    private _canOperate;
+    private _create;
+    private _createLabel;
+    startEdit(): void;
+    mouseDragStart(): void;
+    mouseDragChange(position: any): void;
+    endEdit(): void;
+    show(isShow: boolean): void;
+    destroy(): void;
+}
+export default DragPoint;

package/dist/esm/drawer/shape/DragPoint.js

@@ -0,0 +1,211 @@
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as Cesium from 'deeptwins-cesium';
+import { v4 as uuidV4 } from 'uuid';
+import PositionProperty from "../../property/PositionProperty";
+import * as utils from "../../tool/utils";
+
+// 拖动点样式
+var DRAG_POINT_STYLE = {
+  pixelSize: 10,
+  color: '#ffffff',
+  outline: true,
+  outlineColor: '#1890FF',
+  outlineWidth: 2
+};
+
+// 临时拖动点样式
+var TEMP_DRAG_POINT_STYLE = {
+  pixelSize: 10,
+  color: '#1890FF',
+  outline: true,
+  outlineColor: '#ffffff',
+  outlineWidth: 2
+};
+
+// 创建可拖动的点
+var DragPoint = /*#__PURE__*/function () {
+  /**
+   * 构造函数，用于创建一个地图元素实例
+   * @param map 地图对象，包含地图上下文信息
+   * @param options 配置选项对象
+   * @param options.positions 点的坐标位置数组
+   * @param options.style 样式配置
+   * @param options.isMiddlePoint 是否为中间点的标识，默认为false
+   */
+  function DragPoint(map, _ref) {
+    var positions = _ref.positions,
+      style = _ref.style,
+      _ref$isMiddlePoint = _ref.isMiddlePoint,
+      isMiddlePoint = _ref$isMiddlePoint === void 0 ? false : _ref$isMiddlePoint;
+    _classCallCheck(this, DragPoint);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "id", '');
+    _defineProperty(this, "layer", void 0);
+    // 是否编辑中
+    _defineProperty(this, "isEditing", false);
+    // 是否是中间点
+    _defineProperty(this, "isMiddlePoint", false);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "labelLayer", void 0);
+    _defineProperty(this, "_geoJson", void 0);
+    _defineProperty(this, "_style", void 0);
+    this._mapContext = map._mapContext;
+    this.id = uuidV4();
+    this.isMiddlePoint = isMiddlePoint;
+    this._geoJson = {
+      type: 'Feature',
+      geometry: {
+        type: 'Point',
+        coordinates: positions
+      }
+    };
+    this._style = style;
+    this._create();
+  }
+  _createClass(DragPoint, [{
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+  }, {
+    key: "getPosition",
+    value: function getPosition() {
+      var _this$_geoJson;
+      var coordinates = (_this$_geoJson = this._geoJson) === null || _this$_geoJson === void 0 || (_this$_geoJson = _this$_geoJson.geometry) === null || _this$_geoJson === void 0 ? void 0 : _this$_geoJson.coordinates;
+      return Array.isArray(coordinates) ? _toConsumableArray(coordinates) : coordinates;
+    }
+
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('DragPoint实例已销毁');
+        return false;
+      }
+      return true;
+    }
+
+    // 创建
+  }, {
+    key: "_create",
+    value: function _create() {
+      if (!this._canOperate()) return;
+      this.layer = this.getMap().addGraphicLayer(this._geoJson, {
+        type: 'point',
+        id: this.id,
+        style: _objectSpread(_objectSpread({}, this._style), {}, {
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
+        }),
+        positionProperty: new PositionProperty()
+      });
+      if (!this.isMiddlePoint) {
+        this._createLabel();
+      }
+    }
+
+    // 创建label
+  }, {
+    key: "_createLabel",
+    value: function _createLabel() {
+      this.labelLayer = this.getMap().addGraphicLayer(this._geoJson, {
+        type: 'label',
+        style: {
+          text: '',
+          font: 'bold 16px Arial',
+          style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+          outlineWidth: 4,
+          eyeOffset: [-20, 0, 0],
+          horizontalOrigin: Cesium.HorizontalOrigin.RIGHT,
+          heightReference: Cesium.HeightReference.NONE,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          show: false
+        },
+        positionProperty: new PositionProperty()
+      });
+    }
+
+    // 开始编辑
+  }, {
+    key: "startEdit",
+    value: function startEdit() {
+      if (!this._canOperate()) return;
+      this.isEditing = true;
+      this.layer && this.layer.setStyle(this.isMiddlePoint ? TEMP_DRAG_POINT_STYLE : DRAG_POINT_STYLE);
+    }
+
+    // 开始鼠标拖拽
+  }, {
+    key: "mouseDragStart",
+    value: function mouseDragStart() {
+      if (this.isMiddlePoint) {
+        this.isMiddlePoint = false;
+        this.layer && this.layer.setStyle(DRAG_POINT_STYLE);
+        this._createLabel();
+      }
+    }
+
+    // 鼠标拖拽
+  }, {
+    key: "mouseDragChange",
+    value: function mouseDragChange(position) {
+      if (!this._canOperate()) return;
+      if (this.layer && position) {
+        var lng = position.lng,
+          lat = position.lat,
+          alt = position.alt;
+        this._geoJson.geometry.coordinates = [lng, lat, alt];
+        this.layer.setData(this._geoJson);
+        this.labelLayer && this.labelLayer.setData(this._geoJson);
+      }
+    }
+
+    // 结束编辑
+  }, {
+    key: "endEdit",
+    value: function endEdit() {
+      if (!this._canOperate()) return;
+      if (this.layer) {
+        this.isEditing = false;
+        this.layer.setStyle(this._style);
+      }
+    }
+
+    // 隐藏
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      if (!this._canOperate()) return;
+      this.layer && this.layer.show(isShow);
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate()) return;
+      this.isDestroyed = true;
+      this.isEditing = false;
+      this.layer && this.layer.remove();
+      this.layer = null;
+      this.labelLayer && this.labelLayer.remove();
+      this.labelLayer = null;
+    }
+  }]);
+  return DragPoint;
+}();
+export default DragPoint;

package/dist/esm/drawer/shape/Elliptic.d.ts

@@ -0,0 +1,38 @@
+import BaseShape from './BaseShape';
+declare class Elliptic extends BaseShape {
+    readonly type: string;
+    shapePolylineLayer: any;
+    shapePolygonLayer: any;
+    private _segments;
+    private _centerPosition;
+    private _handlePosition;
+    constructor(drawContext: any, config: any);
+    private _normalizeSegments;
+    private _toPositionTuple;
+    private _getAltitudeBase;
+    private _getDrawPolylinePositions;
+    private _getDrawPolygonPositions;
+    private _destroyShapeLayers;
+    private _syncShapeLayers;
+    private _buildEllipticPositions;
+    private _getLocalHandleVector;
+    private _getPositionByLocalVector;
+    private _applyGeometry;
+    private _destroyEditHandles;
+    private _createEditHandle;
+    private _syncEditHandles;
+    private _emitMouseMoveChange;
+    private _emitPointsChange;
+    private _finishDraw;
+    transformData(_: any[], config?: any): boolean;
+    addPoint(position: any): void;
+    updateTempPosition(position: any): void;
+    endDraw(): void;
+    startEdit(): void;
+    mouseDragStart(position: any, dragLayer: any): void;
+    mouseDragChange(position: any): void;
+    mouseDragEnd(): void;
+    endEdit(layer: any, emitComplete?: boolean): void;
+    destroy(): void;
+}
+export default Elliptic;