deeptwins-engine-3d 0.0.42

package/dist/drawer/shape/Polygon.js

@@ -0,0 +1,87 @@
+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 _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 _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); }
+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); }
+import { ArcType, CallbackProperty, ClassificationType, defined, Entity, PolygonHierarchy } from 'deeptwins-cesium';
+import BasicGraphics from "../base";
+var Polygon = /*#__PURE__*/function (_BasicGraphics) {
+  _inherits(Polygon, _BasicGraphics);
+  var _super = _createSuper(Polygon);
+  function Polygon() {
+    _classCallCheck(this, Polygon);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Polygon, [{
+    key: "dropPoint",
+    value: function dropPoint(event) {
+      var _this = this;
+      if (!event.position) return;
+      var earthPosition = this.painter.pickCartesian3(event.position);
+      if (earthPosition && defined(earthPosition)) {
+        if (!this.painter._activeShapePoints.length) {
+          this.painter._activeShapePoints.push(earthPosition);
+          var dynamicPositions = new CallbackProperty(function () {
+            return new PolygonHierarchy(_this.painter._activeShapePoints);
+          }, false);
+          this.painter._dynamicShapeEntity = this.painter.addView(this.createShape(dynamicPositions, true));
+        }
+        this.SetBreakpoint(earthPosition);
+      }
+    }
+  }, {
+    key: "playOff",
+    value: function playOff() {
+      // 去除最后一个多余点
+      this._cancel(this.createShape.bind(this));
+      return this._playOff(this.createShape.bind(this));
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this._cancel(this.createShape.bind(this));
+    }
+  }, {
+    key: "createShape",
+    value: function createShape(hierarchy) {
+      var _this2 = this;
+      var isDynamic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var options = isDynamic && !this.sameStyle ? this.dynamicOptions : this.finalOptions;
+      var polygon = Object.assign({}, options, {
+        hierarchy: Array.isArray(hierarchy) ? new PolygonHierarchy(hierarchy) : hierarchy,
+        arcType: ArcType.RHUMB,
+        classificationType: this.painter._model ? ClassificationType.CESIUM_3D_TILE : undefined
+      });
+      var polyline = {
+        width: options.outlineWidth,
+        material: options.outlineColor,
+        positions: Array.isArray(hierarchy) ? [].concat(_toConsumableArray(hierarchy), [hierarchy[0]]) : new CallbackProperty(function () {
+          return [].concat(_toConsumableArray(_this2.painter._activeShapePoints), [_this2.painter._activeShapePoints[0]]);
+        }, false),
+        clampToGround: true,
+        arcType: ArcType.RHUMB,
+        classificationType: this.painter._model ? ClassificationType.CESIUM_3D_TILE : undefined
+      };
+      return new Entity({
+        polygon: polygon,
+        polyline: polyline
+      });
+    }
+  }]);
+  return Polygon;
+}(BasicGraphics);
+export { Polygon as default };

package/dist/drawer/shape/Polyline.d.ts

@@ -0,0 +1,11 @@
+import { Entity } from 'deeptwins-cesium';
+import BasicGraphics from '../base';
+import type { CallbackProperty, Cartesian3 } from 'deeptwins-cesium';
+import type { EventArgs } from '../../tool/cesiumExtends/Subscriber';
+import type { LifeCycle } from '../base';
+export default class Polyline extends BasicGraphics implements LifeCycle {
+    dropPoint(event: EventArgs): void;
+    playOff(): Entity;
+    cancel(): void;
+    createShape(positions: Cartesian3[] | CallbackProperty, isDynamic?: boolean): Entity;
+}

package/dist/drawer/shape/Polyline.js

@@ -0,0 +1,54 @@
+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 _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); }
+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); }
+import { ArcType, ClassificationType, Entity } from 'deeptwins-cesium';
+import BasicGraphics from "../base";
+var Polyline = /*#__PURE__*/function (_BasicGraphics) {
+  _inherits(Polyline, _BasicGraphics);
+  var _super = _createSuper(Polyline);
+  function Polyline() {
+    _classCallCheck(this, Polyline);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Polyline, [{
+    key: "dropPoint",
+    value: function dropPoint(event) {
+      this._dropPoint(event, this.createShape.bind(this));
+    }
+  }, {
+    key: "playOff",
+    value: function playOff() {
+      return this._playOff(this.createShape.bind(this));
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this._cancel(this.createShape.bind(this));
+    }
+  }, {
+    key: "createShape",
+    value: function createShape(positions) {
+      var isDynamic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var polyline = Object.assign({}, isDynamic && !this.sameStyle ? this.dynamicOptions : this.finalOptions, {
+        positions: positions,
+        arcType: ArcType.RHUMB,
+        classificationType: this.painter._model ? ClassificationType.CESIUM_3D_TILE : undefined
+      });
+      return new Entity({
+        polyline: polyline
+      });
+    }
+  }]);
+  return Polyline;
+}(BasicGraphics);
+export { Polyline as default };

package/dist/drawer/shape/Rectangle.d.ts

@@ -0,0 +1,10 @@
+import { CallbackProperty, Cartesian3, Entity } from 'deeptwins-cesium';
+import type { LifeCycle } from '../base';
+import BasicGraphics from '../base';
+import type { EventArgs } from '../../tool/cesiumExtends/Subscriber';
+export default class Rectangle extends BasicGraphics implements LifeCycle {
+    dropPoint(move: EventArgs): void;
+    playOff(): Entity;
+    cancel(): void;
+    createShape(hierarchy: Cartesian3[] | CallbackProperty, isDynamic?: boolean): Entity;
+}

package/dist/drawer/shape/Rectangle.js

@@ -0,0 +1,85 @@
+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 _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 _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); }
+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); }
+import { CallbackProperty, Cartesian2, Cartesian3, Rectangle as CesiumRectangle, Entity, JulianDate } from 'deeptwins-cesium';
+import BasicGraphics from "../base";
+import { cartesian3ToLngLatAlt } from "../../tool/utils";
+var Rectangle = /*#__PURE__*/function (_BasicGraphics) {
+  _inherits(Rectangle, _BasicGraphics);
+  var _super = _createSuper(Rectangle);
+  function Rectangle() {
+    _classCallCheck(this, Rectangle);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Rectangle, [{
+    key: "dropPoint",
+    value: function dropPoint(move) {
+      this._dropPoint(move, this.createShape.bind(this));
+    }
+  }, {
+    key: "playOff",
+    value: function playOff() {
+      var _this$result$rectangl;
+      this.painter._activeShapePoints.pop();
+      if (this._onPointsChange) {
+        var _points = this.painter._activeShapePoints.map(function (t) {
+          return cartesian3ToLngLatAlt(t);
+        });
+        this._onPointsChange(_toConsumableArray(this.painter._activeShapePoints), _points);
+      }
+      this.result = this.createShape(this.painter._activeShapePoints);
+      var rect = (_this$result$rectangl = this.result.rectangle) === null || _this$result$rectangl === void 0 || (_this$result$rectangl = _this$result$rectangl.coordinates) === null || _this$result$rectangl === void 0 ? void 0 : _this$result$rectangl.getValue(new JulianDate());
+      var west = rect.west,
+        east = rect.east,
+        north = rect.north,
+        south = rect.south;
+      var positions = [[west, north], [east, north], [east, south], [west, south]].map(function (pos) {
+        return Cartesian3.fromRadians(pos[0], pos[1], 0);
+      });
+      var points = positions.map(function (t) {
+        return cartesian3ToLngLatAlt(t);
+      });
+      if (this._complete) this._complete(this.result, positions, points);
+      this.painter.reset();
+      this._lastClickPosition = new Cartesian2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+      return this.result;
+    }
+  }, {
+    key: "cancel",
+    value: function cancel() {
+      this._cancel(this.createShape.bind(this));
+    }
+  }, {
+    key: "createShape",
+    value: function createShape(hierarchy) {
+      var isDynamic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var target = Array.isArray(hierarchy) ? hierarchy : hierarchy.getValue(JulianDate.now());
+      var rectangle = Object.assign({}, isDynamic && !this.sameStyle ? this.dynamicOptions : this.finalOptions, {
+        coordinates: new CallbackProperty(function () {
+          return CesiumRectangle.fromCartesianArray(target);
+        }, false)
+      });
+      return new Entity({
+        rectangle: rectangle
+      });
+    }
+  }]);
+  return Rectangle;
+}(BasicGraphics);
+export { Rectangle as default };

package/dist/drawer/typings.d.ts

@@ -0,0 +1,106 @@
+import type Cesium from 'deeptwins-cesium';
+import type { Cartesian3, EllipseGraphics, Entity, PointGraphics, PolygonGraphics, PolylineGraphics, RectangleGraphics } from 'deeptwins-cesium';
+import Drawer from '.';
+import type { EventArgs, EventType } from '../tool/cesiumExtends/Subscriber';
+import type { BasicGraphicsOptions } from './base';
+export type hierarchyHandler = (hierarchy: Cesium.Cartesian3[] | Cesium.CallbackProperty | Cartesian3) => Cesium.Entity.ConstructorOptions;
+export type OverrideEntityFunc = (this: Drawer, action: EventType, entity: Entity) => Entity | void;
+export type OperationType = {
+    /**
+     * @desc 勾画开始事件
+     * @type EventType
+     * @default LEFT_CLICK
+     */
+    START?: EventType;
+    /**
+     * @desc 勾画移动事件
+     * @type EventType
+     * @default MOUSE_MOVE
+     */
+    MOVING?: EventType;
+    /**
+     * @desc 勾画撤销事件
+     * @type EventType
+     * @default RIGHT_CLICK
+     */
+    CANCEL?: EventType;
+    /**
+     * @desc 勾画结束事件
+     * @type EventType
+     * @default LEFT_DOUBLE_CLICK
+     */
+    END?: EventType;
+};
+export type DrawerCallback = (entity: Entity) => void;
+/**
+ * @desc 操作回调
+ * @param action 事件名
+ * @param move 事件参数
+ */
+export type ActionCallback = (action: EventType, move: EventArgs) => void;
+/**
+ * 绘制状态
+ */
+export type Status = 'INIT' | 'START' | 'PAUSE' | 'DESTROY';
+export interface DrawOption {
+    /**
+     * @desc 是否使用地形，当开启时需要浏览器支持地形选取功能，如果不支持将会被关闭
+     */
+    terrain: boolean;
+    /** 是否在模型上选点 */
+    model: boolean;
+    /**
+     * @desc  操作方式
+     */
+    operateType: OperationType;
+    dynamicGraphicsOptions: {
+        point: PointGraphics.ConstructorOptions;
+        polyline: PolylineGraphics.ConstructorOptions;
+        polygon: PolygonGraphics.ConstructorOptions;
+        ellipse: EllipseGraphics.ConstructorOptions;
+        rectangle: RectangleGraphics.ConstructorOptions;
+    };
+    /**
+     * 鼠标事件回调
+     */
+    action?: ActionCallback;
+    sameStyle: boolean;
+    /** 自定义编辑时鼠标移动的提示 */
+    tips: {
+        /** 默认为 'Click to draw' */
+        init?: string | Element;
+        /** 默认为 'LeftClick to add a point, rightClick remove point, doubleClick end drawing' */
+        start?: string | Element;
+        /** 默认为 '' */
+        end?: string | Element;
+    };
+}
+export type StartOption = {
+    /**
+     * @desc 勾画类型 目前支持 Polygon、Line、Point、Circle、Rectangle
+     */
+    type: 'polygon' | 'polyline' | 'point' | 'ellipse' | 'rectangle';
+    /**
+     * 是否只勾画一次，如果设为true，则在第一勾画结束时停止
+     * @default undefined
+     */
+    once?: boolean;
+    /**
+     * @desc 是否使用单例模式，如果开启，当勾画第二个图形时会销毁第一个图形
+     */
+    oneInstance?: boolean;
+    /**
+     * @desc 勾画的Entity选项，如Point对应#PointGraphics.ConstructorOptions
+     */
+    finalOptions?: object;
+    /**
+     * @desc 动态勾画没有确定图形时的图形配置，类型与options选项相同
+     */
+    dynamicOptions?: object;
+    /**
+     * 点改变的回调
+     */
+    onPointsChange?: BasicGraphicsOptions['onPointsChange'];
+    /** 结束绘制的回调 */
+    complete?: (entity: Entity, positions: Cartesian3[], coordinates: any[]) => void;
+};

package/dist/drawer/typings.js

@@ -0,0 +1 @@
+export {};

package/dist/global.less

@@ -0,0 +1,3 @@
+#yunjinglogo {
+  display: none;
+}

package/dist/graphicLayer/BaseEntity.d.ts

@@ -0,0 +1,12 @@
+export default class BaseEntity {
+    id: any;
+    source: any;
+    style: any;
+    graphic: any;
+    entity: any;
+    positionProperty: any;
+    type: string;
+    isEntity: boolean;
+    constructor(options: any);
+    updateStyle(originStyle: any, style: any): void;
+}

package/dist/graphicLayer/BaseEntity.js

@@ -0,0 +1,45 @@
+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 _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 { merge } from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
+
+// 基础实体图层
+var BaseEntity = /*#__PURE__*/function () {
+  function BaseEntity(options) {
+    _classCallCheck(this, BaseEntity);
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "source", void 0);
+    _defineProperty(this, "style", void 0);
+    _defineProperty(this, "graphic", void 0);
+    _defineProperty(this, "entity", void 0);
+    _defineProperty(this, "positionProperty", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "isEntity", true);
+    this.id = uuidv4();
+    var style = options.style,
+      source = options.source,
+      positionProperty = options.positionProperty;
+    this.type = options.type;
+    this.positionProperty = positionProperty;
+    this.source = source;
+    this.style = style || {};
+  }
+
+  // 更新样式
+  _createClass(BaseEntity, [{
+    key: "updateStyle",
+    value: function updateStyle(originStyle, style) {
+      this.style = merge(this.style, originStyle);
+      for (var key in style) {
+        this.entity[this.type][key] = style[key];
+      }
+    }
+  }]);
+  return BaseEntity;
+}();
+export { BaseEntity as default };

package/dist/graphicLayer/BaseLayer.d.ts

@@ -0,0 +1,29 @@
+export default class BaseLayer {
+    id: any;
+    type: any;
+    options: any;
+    sourceId: any;
+    layers: any[];
+    isDestroyed: boolean;
+    primitiveCollection: any;
+    isEntity: boolean;
+    isPrimitive: boolean;
+    private _isCompleteInfo;
+    private _renderClass;
+    private _graphicLayerCollection;
+    constructor({ id, source, options, entity, graphicLayerCollection }: any);
+    private _createPrimitiveCollection;
+    private _createEntity;
+    private _createPrimitive;
+    private _canOperate;
+    show(isShow: boolean): void;
+    private _getOne;
+    setStyle(style: any): void;
+    setStyleOne(layer: any, style: any): void;
+    setData(data: any): void;
+    remove(): void;
+    removeOne(layer: any): void;
+    flyTo(options: any): void;
+    on(type: any, event: any): any;
+    _toDestroy(): void;
+}