mirror of
https://github.com/sakitam-fdd/maptalks.plot.git
synced 2025-12-08 20:35:49 +00:00
722 lines
18 KiB
JavaScript
722 lines
18 KiB
JavaScript
/*!
|
|
* maptalks.plot v0.0.0
|
|
* LICENSE : MIT
|
|
* (c) 2017-2017 https://sakitam-fdd.github.io/maptalks.plot
|
|
*/
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
var maptalks = require('maptalks');
|
|
|
|
var TextArea = 'TextArea';
|
|
var ARC = 'Arc';
|
|
var CURVE = 'Curve';
|
|
var GATHERING_PLACE = 'GatheringPlace';
|
|
var POLYLINE = 'Polyline';
|
|
var FREE_LINE = 'FreeLine';
|
|
var POINT = 'Point';
|
|
var PENNANT = 'Pennant';
|
|
var RECTANGLE = 'RectAngle';
|
|
var CIRCLE = 'Circle';
|
|
var ELLIPSE = 'Ellipse';
|
|
var LUNE = 'Lune';
|
|
var SECTOR = 'Sector';
|
|
var CLOSED_CURVE = 'ClosedCurve';
|
|
var POLYGON = 'Polygon';
|
|
var FREE_POLYGON = 'FreePolygon';
|
|
var ATTACK_ARROW = 'AttackArrow';
|
|
var DOUBLE_ARROW = 'DoubleArrow';
|
|
var STRAIGHT_ARROW = 'StraightArrow';
|
|
var FINE_ARROW = 'FineArrow';
|
|
var ASSAULT_DIRECTION = 'AssaultDirection';
|
|
var TAILED_ATTACK_ARROW = 'TailedAttackArrow';
|
|
var SQUAD_COMBAT = 'SquadCombat';
|
|
var TAILED_SQUAD_COMBAT = 'TailedSquadCombat';
|
|
var RECTFLAG = 'RectFlag';
|
|
var TRIANGLEFLAG = 'TriangleFlag';
|
|
var CURVEFLAG = 'CurveFlag';
|
|
|
|
|
|
var PlotTypes = Object.freeze({
|
|
TextArea: TextArea,
|
|
ARC: ARC,
|
|
CURVE: CURVE,
|
|
GATHERING_PLACE: GATHERING_PLACE,
|
|
POLYLINE: POLYLINE,
|
|
FREE_LINE: FREE_LINE,
|
|
POINT: POINT,
|
|
PENNANT: PENNANT,
|
|
RECTANGLE: RECTANGLE,
|
|
CIRCLE: CIRCLE,
|
|
ELLIPSE: ELLIPSE,
|
|
LUNE: LUNE,
|
|
SECTOR: SECTOR,
|
|
CLOSED_CURVE: CLOSED_CURVE,
|
|
POLYGON: POLYGON,
|
|
FREE_POLYGON: FREE_POLYGON,
|
|
ATTACK_ARROW: ATTACK_ARROW,
|
|
DOUBLE_ARROW: DOUBLE_ARROW,
|
|
STRAIGHT_ARROW: STRAIGHT_ARROW,
|
|
FINE_ARROW: FINE_ARROW,
|
|
ASSAULT_DIRECTION: ASSAULT_DIRECTION,
|
|
TAILED_SQUAD_COMBAT: TAILED_SQUAD_COMBAT,
|
|
TAILED_ATTACK_ARROW: TAILED_ATTACK_ARROW,
|
|
SQUAD_COMBAT: SQUAD_COMBAT,
|
|
RECTFLAG: RECTFLAG,
|
|
TRIANGLEFLAG: TRIANGLEFLAG,
|
|
CURVEFLAG: CURVEFLAG
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
|
return typeof obj;
|
|
} : function (obj) {
|
|
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
var asyncGenerator = function () {
|
|
function AwaitValue(value) {
|
|
this.value = value;
|
|
}
|
|
|
|
function AsyncGenerator(gen) {
|
|
var front, back;
|
|
|
|
function send(key, arg) {
|
|
return new Promise(function (resolve, reject) {
|
|
var request = {
|
|
key: key,
|
|
arg: arg,
|
|
resolve: resolve,
|
|
reject: reject,
|
|
next: null
|
|
};
|
|
|
|
if (back) {
|
|
back = back.next = request;
|
|
} else {
|
|
front = back = request;
|
|
resume(key, arg);
|
|
}
|
|
});
|
|
}
|
|
|
|
function resume(key, arg) {
|
|
try {
|
|
var result = gen[key](arg);
|
|
var value = result.value;
|
|
|
|
if (value instanceof AwaitValue) {
|
|
Promise.resolve(value.value).then(function (arg) {
|
|
resume("next", arg);
|
|
}, function (arg) {
|
|
resume("throw", arg);
|
|
});
|
|
} else {
|
|
settle(result.done ? "return" : "normal", result.value);
|
|
}
|
|
} catch (err) {
|
|
settle("throw", err);
|
|
}
|
|
}
|
|
|
|
function settle(type, value) {
|
|
switch (type) {
|
|
case "return":
|
|
front.resolve({
|
|
value: value,
|
|
done: true
|
|
});
|
|
break;
|
|
|
|
case "throw":
|
|
front.reject(value);
|
|
break;
|
|
|
|
default:
|
|
front.resolve({
|
|
value: value,
|
|
done: false
|
|
});
|
|
break;
|
|
}
|
|
|
|
front = front.next;
|
|
|
|
if (front) {
|
|
resume(front.key, front.arg);
|
|
} else {
|
|
back = null;
|
|
}
|
|
}
|
|
|
|
this._invoke = send;
|
|
|
|
if (typeof gen.return !== "function") {
|
|
this.return = undefined;
|
|
}
|
|
}
|
|
|
|
if (typeof Symbol === "function" && Symbol.asyncIterator) {
|
|
AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
|
|
return this;
|
|
};
|
|
}
|
|
|
|
AsyncGenerator.prototype.next = function (arg) {
|
|
return this._invoke("next", arg);
|
|
};
|
|
|
|
AsyncGenerator.prototype.throw = function (arg) {
|
|
return this._invoke("throw", arg);
|
|
};
|
|
|
|
AsyncGenerator.prototype.return = function (arg) {
|
|
return this._invoke("return", arg);
|
|
};
|
|
|
|
return {
|
|
wrap: function (fn) {
|
|
return function () {
|
|
return new AsyncGenerator(fn.apply(this, arguments));
|
|
};
|
|
},
|
|
await: function (value) {
|
|
return new AwaitValue(value);
|
|
}
|
|
};
|
|
}();
|
|
|
|
|
|
|
|
|
|
|
|
var classCallCheck = function (instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var inherits = function (subClass, superClass) {
|
|
if (typeof superClass !== "function" && superClass !== null) {
|
|
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
|
|
}
|
|
|
|
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
constructor: {
|
|
value: subClass,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var possibleConstructorReturn = function (self, call) {
|
|
if (!self) {
|
|
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
}
|
|
|
|
return call && (typeof call === "object" || typeof call === "function") ? call : self;
|
|
};
|
|
|
|
var Canvas2d = maptalks.Canvas;
|
|
var options = {
|
|
'arcDegree': 90
|
|
};
|
|
|
|
var Curve = function (_maptalks$LineString) {
|
|
inherits(Curve, _maptalks$LineString);
|
|
|
|
function Curve() {
|
|
classCallCheck(this, Curve);
|
|
return possibleConstructorReturn(this, _maptalks$LineString.apply(this, arguments));
|
|
}
|
|
|
|
Curve.prototype._arc = function _arc(ctx, points, lineOpacity) {
|
|
var degree = this.options['arcDegree'] * Math.PI / 180;
|
|
for (var i = 1, l = points.length; i < l; i++) {
|
|
Canvas2d._arcBetween(ctx, points[i - 1], points[i], degree);
|
|
Canvas2d._stroke(ctx, lineOpacity);
|
|
}
|
|
};
|
|
|
|
Curve.prototype._quadraticCurve = function _quadraticCurve(ctx, points) {
|
|
if (points.length <= 2) {
|
|
Canvas2d._path(ctx, points);
|
|
return;
|
|
}
|
|
Canvas2d.quadraticCurve(ctx, points);
|
|
};
|
|
|
|
Curve.prototype._bezierCurve = function _bezierCurve(ctx, points) {
|
|
if (points.length <= 3) {
|
|
Canvas2d._path(ctx, points);
|
|
return;
|
|
}
|
|
var i = void 0,
|
|
l = void 0;
|
|
for (i = 1, l = points.length; i + 2 < l; i += 3) {
|
|
ctx.bezierCurveTo(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y, points[i + 2].x, points[i + 2].y);
|
|
}
|
|
if (i < l) {
|
|
for (; i < l; i++) {
|
|
ctx.lineTo(points[i].x, points[i].y);
|
|
}
|
|
}
|
|
};
|
|
|
|
Curve.prototype._toJSON = function _toJSON(options) {
|
|
return {
|
|
'feature': this.toGeoJSON(options),
|
|
'subType': 'Curve'
|
|
};
|
|
};
|
|
|
|
Curve.prototype._paintOn = function _paintOn(ctx, points, lineOpacity) {
|
|
ctx.beginPath();
|
|
this._arc(ctx, points, lineOpacity);
|
|
Canvas2d._stroke(ctx, lineOpacity);
|
|
this._paintArrow(ctx, points, lineOpacity);
|
|
};
|
|
|
|
Curve.fromJSON = function fromJSON(json) {
|
|
var feature = json['feature'];
|
|
var arc = new Curve(feature['geometry']['coordinates'], json['options']);
|
|
arc.setProperties(feature['properties']);
|
|
return arc;
|
|
};
|
|
|
|
return Curve;
|
|
}(maptalks.LineString);
|
|
|
|
Curve.registerJSONType('Curve');
|
|
Curve.mergeOptions(options);
|
|
|
|
var Coordinate$1 = maptalks.Coordinate;
|
|
var options$1 = {
|
|
'arrowStyle': null,
|
|
'arrowPlacement': 'vertex-last',
|
|
'clipToPaint': true
|
|
};
|
|
|
|
var Polyline = function (_maptalks$LineString) {
|
|
inherits(Polyline, _maptalks$LineString);
|
|
|
|
function Polyline(coordinates) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
classCallCheck(this, Polyline);
|
|
|
|
var _this = possibleConstructorReturn(this, _maptalks$LineString.call(this, options));
|
|
|
|
_this.type = 'Polyline';
|
|
if (coordinates) {
|
|
_this.setCoordinates(coordinates);
|
|
}
|
|
return _this;
|
|
}
|
|
|
|
Polyline.prototype._exportGeoJSONGeometry = function _exportGeoJSONGeometry() {
|
|
var points = this.getCoordinates();
|
|
var coordinates = Coordinate$1.toNumberArrays(points);
|
|
return {
|
|
'type': 'LineString',
|
|
'coordinates': coordinates
|
|
};
|
|
};
|
|
|
|
Polyline.prototype._toJSON = function _toJSON(options) {
|
|
return {
|
|
'feature': this.toGeoJSON(options)
|
|
};
|
|
};
|
|
|
|
return Polyline;
|
|
}(maptalks.LineString);
|
|
|
|
Polyline.mergeOptions(options$1);
|
|
|
|
Polyline.registerJSONType('Polyline');
|
|
|
|
var Coordinate$2 = maptalks.Coordinate;
|
|
var options$2 = {
|
|
'arrowStyle': null,
|
|
'arrowPlacement': 'vertex-last',
|
|
'clipToPaint': true
|
|
};
|
|
|
|
var FreeLine = function (_maptalks$LineString) {
|
|
inherits(FreeLine, _maptalks$LineString);
|
|
|
|
function FreeLine(coordinates) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
classCallCheck(this, FreeLine);
|
|
|
|
var _this = possibleConstructorReturn(this, _maptalks$LineString.call(this, options));
|
|
|
|
_this.type = 'FreeLine';
|
|
if (coordinates) {
|
|
_this.setCoordinates(coordinates);
|
|
}
|
|
return _this;
|
|
}
|
|
|
|
FreeLine.prototype._exportGeoJSONGeometry = function _exportGeoJSONGeometry() {
|
|
var points = this.getCoordinates();
|
|
var coordinates = Coordinate$2.toNumberArrays(points);
|
|
return {
|
|
'type': 'LineString',
|
|
'coordinates': coordinates
|
|
};
|
|
};
|
|
|
|
FreeLine.prototype._toJSON = function _toJSON(options) {
|
|
return {
|
|
'feature': this.toGeoJSON(options)
|
|
};
|
|
};
|
|
|
|
return FreeLine;
|
|
}(maptalks.LineString);
|
|
|
|
FreeLine.mergeOptions(options$2);
|
|
|
|
FreeLine.registerJSONType('FreeLine');
|
|
|
|
var RegisterModes = {};
|
|
RegisterModes[CURVE] = {
|
|
'action': 'clickDblclick',
|
|
'create': function create(path) {
|
|
return new Curve(path);
|
|
},
|
|
'update': function update(path, geometry) {
|
|
geometry.setCoordinates(path);
|
|
},
|
|
'generate': function generate(geometry) {
|
|
return geometry;
|
|
}
|
|
};
|
|
RegisterModes[POLYLINE] = {
|
|
'action': 'clickDblclick',
|
|
'create': function create(path) {
|
|
return new Polyline(path);
|
|
},
|
|
'update': function update(path, geometry) {
|
|
geometry.setCoordinates(path);
|
|
},
|
|
'generate': function generate(geometry) {
|
|
return geometry;
|
|
}
|
|
};
|
|
RegisterModes[FREE_LINE] = {
|
|
'action': 'mouseup',
|
|
'create': function create(path) {
|
|
return new FreeLine(path);
|
|
},
|
|
'update': function update(path, geometry) {
|
|
geometry.setCoordinates(path);
|
|
},
|
|
'generate': function generate(geometry) {
|
|
return geometry;
|
|
}
|
|
};
|
|
|
|
var isObject = function isObject(value) {
|
|
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
|
|
return value !== null && (type === 'object' || type === 'function');
|
|
};
|
|
|
|
var merge = function merge(a, b) {
|
|
for (var key in b) {
|
|
if (isObject(b[key]) && isObject(a[key])) {
|
|
merge(a[key], b[key]);
|
|
} else {
|
|
a[key] = b[key];
|
|
}
|
|
}
|
|
return a;
|
|
};
|
|
|
|
var Polygon$1 = maptalks.Polygon;
|
|
var _options = {
|
|
'symbol': {
|
|
'lineColor': '#000',
|
|
'lineWidth': 2,
|
|
'lineOpacity': 1,
|
|
'polygonFill': '#fff',
|
|
'polygonOpacity': 0.3
|
|
},
|
|
'doubleClickZoom': false,
|
|
'mode': null,
|
|
'once': false,
|
|
'ignoreMouseleave': true
|
|
};
|
|
var registeredMode = {};
|
|
|
|
var PlotDraw = function (_maptalks$DrawTool) {
|
|
inherits(PlotDraw, _maptalks$DrawTool);
|
|
|
|
function PlotDraw() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
classCallCheck(this, PlotDraw);
|
|
|
|
var $options = merge(_options, options);
|
|
|
|
var _this = possibleConstructorReturn(this, _maptalks$DrawTool.call(this, $options));
|
|
|
|
_this.options = $options;
|
|
_this._checkMode();
|
|
return _this;
|
|
}
|
|
|
|
PlotDraw.prototype._getRegisterMode = function _getRegisterMode() {
|
|
var mode = this.getMode();
|
|
var registerMode = PlotDraw.getRegisterMode(mode);
|
|
if (!registerMode) {
|
|
throw new Error(mode + ' is not a valid mode of DrawTool.');
|
|
}
|
|
return registerMode;
|
|
};
|
|
|
|
PlotDraw.prototype.setSymbol = function setSymbol(symbol) {
|
|
if (!symbol) {
|
|
return this;
|
|
}
|
|
this.options['symbol'] = symbol;
|
|
if (this._geometry) {
|
|
this._geometry.setSymbol(symbol);
|
|
}
|
|
return this;
|
|
};
|
|
|
|
PlotDraw.prototype._clickForPath = function _clickForPath(param) {
|
|
var registerMode = this._getRegisterMode();
|
|
var coordinate = param['coordinate'];
|
|
var symbol = this.getSymbol();
|
|
if (!this._geometry) {
|
|
this._clickCoords = [coordinate];
|
|
this._geometry = registerMode['create'](this._clickCoords, param);
|
|
if (symbol) {
|
|
this._geometry.setSymbol(symbol);
|
|
}
|
|
this._addGeometryToStage(this._geometry);
|
|
|
|
this._fireEvent('drawstart', param);
|
|
} else {
|
|
if (!(this._historyPointer === null)) {
|
|
this._clickCoords = this._clickCoords.slice(0, this._historyPointer);
|
|
}
|
|
this._clickCoords.push(coordinate);
|
|
this._historyPointer = this._clickCoords.length;
|
|
registerMode['update'](this._clickCoords, this._geometry, param);
|
|
|
|
this._fireEvent('drawvertex', param);
|
|
}
|
|
};
|
|
|
|
PlotDraw.prototype._mousemoveForPath = function _mousemoveForPath(param) {
|
|
var map = this.getMap();
|
|
if (!this._geometry || !map || map.isInteracting()) {
|
|
return;
|
|
}
|
|
var containerPoint = this._getMouseContainerPoint(param);
|
|
if (!this._isValidContainerPoint(containerPoint)) {
|
|
return;
|
|
}
|
|
var coordinate = param['coordinate'];
|
|
var registerMode = this._getRegisterMode();
|
|
var path = this._clickCoords.slice(0, this._historyPointer);
|
|
if (path && path.length > 0 && coordinate.equals(path[path.length - 1])) {
|
|
return;
|
|
}
|
|
registerMode['update'](path.concat([coordinate]), this._geometry, param);
|
|
|
|
this._fireEvent('mousemove', param);
|
|
};
|
|
|
|
PlotDraw.prototype._dblclickForPath = function _dblclickForPath(param) {
|
|
if (!this._geometry) {
|
|
return;
|
|
}
|
|
var containerPoint = this._getMouseContainerPoint(param);
|
|
if (!this._isValidContainerPoint(containerPoint)) {
|
|
return;
|
|
}
|
|
var registerMode = this._getRegisterMode();
|
|
var coordinate = param['coordinate'];
|
|
var path = this._clickCoords;
|
|
path.push(coordinate);
|
|
if (path.length < 2) {
|
|
return;
|
|
}
|
|
|
|
var nIndexes = [];
|
|
for (var i = 1, len = path.length; i < len; i++) {
|
|
if (path[i].x === path[i - 1].x && path[i].y === path[i - 1].y) {
|
|
nIndexes.push(i);
|
|
}
|
|
}
|
|
for (var _i = nIndexes.length - 1; _i >= 0; _i--) {
|
|
path.splice(nIndexes[_i], 1);
|
|
}
|
|
|
|
if (path.length < 2 || this._geometry && this._geometry instanceof Polygon$1 && path.length < 3) {
|
|
return;
|
|
}
|
|
registerMode['update'](path, this._geometry, param);
|
|
this.endDraw(param);
|
|
};
|
|
|
|
PlotDraw.prototype._mousedownToDraw = function _mousedownToDraw(param) {
|
|
var map = this._map;
|
|
var registerMode = this._getRegisterMode();
|
|
var me = this;
|
|
var firstPoint = this._getMouseContainerPoint(param);
|
|
if (!this._isValidContainerPoint(firstPoint)) {
|
|
return false;
|
|
}
|
|
|
|
function genGeometry(evt) {
|
|
var symbol = me.getSymbol();
|
|
var geometry = me._geometry;
|
|
if (!geometry) {
|
|
geometry = registerMode['create'](evt.coordinate, evt);
|
|
geometry.setSymbol(symbol);
|
|
me._addGeometryToStage(geometry);
|
|
me._geometry = geometry;
|
|
} else {
|
|
registerMode['update'](evt.coordinate, geometry, evt);
|
|
}
|
|
}
|
|
|
|
var onMouseMove = function onMouseMove(evt) {
|
|
if (!this._geometry) {
|
|
return false;
|
|
}
|
|
var current = this._getMouseContainerPoint(evt);
|
|
if (!this._isValidContainerPoint(current)) {
|
|
return false;
|
|
}
|
|
genGeometry(evt);
|
|
this._fireEvent('mousemove', param);
|
|
return false;
|
|
};
|
|
|
|
var onMouseUp = function onMouseUp(evt) {
|
|
map.off('mousemove', onMouseMove, this);
|
|
map.off('mouseup', onMouseUp, this);
|
|
if (!this.options['ignoreMouseleave']) {
|
|
map.off('mouseleave', onMouseUp, this);
|
|
}
|
|
if (!this._geometry) {
|
|
return false;
|
|
}
|
|
var current = this._getMouseContainerPoint(evt);
|
|
if (this._isValidContainerPoint(current)) {
|
|
genGeometry(evt);
|
|
}
|
|
this.endDraw(param);
|
|
return false;
|
|
};
|
|
|
|
this._fireEvent('drawstart', param);
|
|
genGeometry(param);
|
|
map.on('mousemove', onMouseMove, this);
|
|
map.on('mouseup', onMouseUp, this);
|
|
if (!this.options['ignoreMouseleave']) {
|
|
map.on('mouseleave', onMouseUp, this);
|
|
}
|
|
return false;
|
|
};
|
|
|
|
PlotDraw.prototype.getEvents = function getEvents() {
|
|
var action = this._getRegisterMode()['action'];
|
|
if (action === 'clickDblclick') {
|
|
return {
|
|
'click': this._clickForPath,
|
|
'mousemove': this._mousemoveForPath,
|
|
'dblclick': this._dblclickForPath
|
|
};
|
|
} else if (action === 'click') {
|
|
return {
|
|
'click': this._clickForPoint
|
|
};
|
|
} else if (action === 'drag') {
|
|
return {
|
|
'mousedown': this._mousedownToDraw
|
|
};
|
|
} else if (action === 'mouseup') {
|
|
return {
|
|
'mousedown': this._mousedownToDraw
|
|
};
|
|
}
|
|
return null;
|
|
};
|
|
|
|
PlotDraw.registerMode = function registerMode(name, modeAction) {
|
|
registeredMode[name.toLowerCase()] = modeAction;
|
|
};
|
|
|
|
PlotDraw.getRegisterMode = function getRegisterMode(name) {
|
|
return registeredMode[name.toLowerCase()];
|
|
};
|
|
|
|
PlotDraw.registeredModes = function registeredModes(modes) {
|
|
if (modes) {
|
|
for (var _iterator = Reflect.ownKeys(modes), _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
|
|
var _ref;
|
|
|
|
if (_isArray) {
|
|
if (_i2 >= _iterator.length) break;
|
|
_ref = _iterator[_i2++];
|
|
} else {
|
|
_i2 = _iterator.next();
|
|
if (_i2.done) break;
|
|
_ref = _i2.value;
|
|
}
|
|
|
|
var key = _ref;
|
|
|
|
if (!key.match(/^(?:constructor|prototype|arguments|caller|name|bind|call|apply|toString|length)$/)) {
|
|
var desc = Object.getOwnPropertyDescriptor(modes, key);
|
|
var _key = key.toLowerCase();
|
|
Object.defineProperty(registeredMode, _key, desc);
|
|
console.log(registeredMode);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
return PlotDraw;
|
|
}(maptalks.DrawTool);
|
|
|
|
PlotDraw.registeredModes(RegisterModes);
|
|
|
|
exports.PlotDraw = PlotDraw;
|
|
exports.PlotTypes = PlotTypes;
|