@antv/l7-layers 2.21.1 → 2.21.2

package/es/core/CommonStyleAttribute.js

@@ -1,5 +1,5 @@
 import { AttributeType, gl } from '@antv/l7-core';
-export var ShaderLocation = /*#__PURE__*/function (ShaderLocation) {
+export let ShaderLocation = /*#__PURE__*/function (ShaderLocation) {
   ShaderLocation[ShaderLocation["POSITION"] = 0] = "POSITION";
   ShaderLocation[ShaderLocation["COLOR"] = 1] = "COLOR";
   ShaderLocation[ShaderLocation["VERTEX_ID"] = 2] = "VERTEX_ID";
@@ -34,9 +34,10 @@ export function getCommonStyleAttributeOptions(name) {
             type: gl.FLOAT
           },
           size: 1,
-          update: function update(feature) {
-            var _feature$rotation = feature.rotation,
-              rotation = _feature$rotation === void 0 ? 0 : _feature$rotation;
+          update: feature => {
+            const {
+              rotation = 0
+            } = feature;
             return Array.isArray(rotation) ? [rotation[0]] : [rotation];
           }
         }
@@ -55,9 +56,10 @@ export function getCommonStyleAttributeOptions(name) {
             type: gl.FLOAT
           },
           size: 4,
-          update: function update(feature) {
-            var _feature$stroke = feature.stroke,
-              stroke = _feature$stroke === void 0 ? [1, 1, 1, 1] : _feature$stroke;
+          update: feature => {
+            const {
+              stroke = [1, 1, 1, 1]
+            } = feature;
             return stroke;
           }
         }
@@ -76,9 +78,10 @@ export function getCommonStyleAttributeOptions(name) {
             type: gl.FLOAT
           },
           size: 1,
-          update: function update(feature) {
-            var _feature$opacity = feature.opacity,
-              op = _feature$opacity === void 0 ? 1 : _feature$opacity;
+          update: feature => {
+            const {
+              opacity: op = 1
+            } = feature;
             return [op];
           }
         }
@@ -97,9 +100,10 @@ export function getCommonStyleAttributeOptions(name) {
             type: gl.FLOAT
           },
           size: 1,
-          update: function update(feature) {
-            var _feature$extrusionBas = feature.extrusionBase,
-              op = _feature$extrusionBas === void 0 ? 0 : _feature$extrusionBas;
+          update: feature => {
+            const {
+              extrusionBase: op = 0
+            } = feature;
             return [op];
           }
         }
@@ -118,8 +122,10 @@ export function getCommonStyleAttributeOptions(name) {
             type: gl.FLOAT
           },
           size: 2,
-          update: function update(feature) {
-            var epo = feature.offsets;
+          update: feature => {
+            const {
+              offsets: epo
+            } = feature;
             return epo;
           }
         }
@@ -138,9 +144,10 @@ export function getCommonStyleAttributeOptions(name) {
             type: gl.FLOAT
           },
           size: 1,
-          update: function update(feature) {
-            var _feature$thetaOffset = feature.thetaOffset,
-              op = _feature$thetaOffset === void 0 ? 1 : _feature$thetaOffset;
+          update: feature => {
+            const {
+              thetaOffset: op = 1
+            } = feature;
             return [op];
           }
         }

package/es/core/LayerPickService.js

@@ -1,149 +1,100 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { lngLatInExtent } from '@antv/l7-utils';
-var BaseLayerPickService = /*#__PURE__*/function () {
-  function BaseLayerPickService(layer) {
-    _classCallCheck(this, BaseLayerPickService);
+export default class BaseLayerPickService {
+  constructor(layer) {
+    _defineProperty(this, "layer", void 0);
     this.layer = layer;
   }
-  _createClass(BaseLayerPickService, [{
-    key: "pickRender",
-    value: function pickRender(target) {
-      var container = this.layer.getContainer();
-      var layerService = container.layerService;
-      var layer = this.layer;
-      // 瓦片图层的拾取绘制
-      if (layer.tileLayer) {
-        return layer.tileLayer.pickRender(target);
-      }
-      // 渲染瓦片图层的拾取
-      layer.hooks.beforePickingEncode.call();
-      layerService.renderTileLayerMask(layer);
-      layer.renderModels({
-        ispick: true
-      });
-      layer.hooks.afterPickingEncode.call();
+  pickRender(target) {
+    const container = this.layer.getContainer();
+    const layerService = container.layerService;
+    const layer = this.layer;
+    // 瓦片图层的拾取绘制
+    if (layer.tileLayer) {
+      return layer.tileLayer.pickRender(target);
     }
-  }, {
-    key: "pick",
-    value: function () {
-      var _pick = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(layer, target) {
-        var container, pickingService;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              container = this.layer.getContainer();
-              pickingService = container.pickingService;
-              if (!(layer.type === 'RasterLayer')) {
-                _context.next = 4;
-                break;
-              }
-              return _context.abrupt("return", this.pickRasterLayer(layer, target));
-            case 4:
-              this.pickRender(target);
-              return _context.abrupt("return", pickingService.pickFromPickingFBO(layer, target));
-            case 6:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function pick(_x, _x2) {
-        return _pick.apply(this, arguments);
-      }
-      return pick;
-    }()
-  }, {
-    key: "pickRasterLayer",
-    value: function pickRasterLayer(layer, target, parent) {
-      var container = this.layer.getContainer();
-      var pickingService = container.pickingService;
-      var mapService = container.mapService;
-      var extent = this.layer.getSource().extent;
-      var isPick = lngLatInExtent(target.lngLat, extent);
-      var layerTarget = {
-        x: target.x,
-        y: target.y,
-        type: target.type,
-        lngLat: target.lngLat,
-        target: target,
-        rasterValue: null
-      };
-      var adviceTarget = parent ? parent : layer;
-      if (isPick) {
-        var rasterValue = this.readRasterValue(layer, extent, mapService, target.x, target.y);
-        layerTarget.rasterValue = rasterValue;
-        pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
-        return true;
-      } else {
-        layerTarget.type = target.type === 'mousemove' ? 'mouseout' : 'un' + target.type;
-        pickingService.triggerHoverOnLayer(adviceTarget, _objectSpread(_objectSpread({}, layerTarget), {}, {
-          type: 'unpick'
-        }));
-        pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
-        return false;
+    // 渲染瓦片图层的拾取
+    layer.hooks.beforePickingEncode.call();
+    layerService.renderTileLayerMask(layer);
+    layer.renderModels({
+      ispick: true
+    });
+    layer.hooks.afterPickingEncode.call();
+  }
+  pick(layer, target) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const container = _this.layer.getContainer();
+      const pickingService = container.pickingService;
+      if (layer.type === 'RasterLayer') {
+        return _this.pickRasterLayer(layer, target);
       }
+      _this.pickRender(target);
+      return pickingService.pickFromPickingFBO(layer, target);
+    })();
+  }
+  pickRasterLayer(layer, target, parent) {
+    const container = this.layer.getContainer();
+    const pickingService = container.pickingService;
+    const mapService = container.mapService;
+    const extent = this.layer.getSource().extent;
+    const isPick = lngLatInExtent(target.lngLat, extent);
+    const layerTarget = {
+      x: target.x,
+      y: target.y,
+      type: target.type,
+      lngLat: target.lngLat,
+      target,
+      rasterValue: null
+    };
+    const adviceTarget = parent ? parent : layer;
+    if (isPick) {
+      const rasterValue = this.readRasterValue(layer, extent, mapService, target.x, target.y);
+      layerTarget.rasterValue = rasterValue;
+      pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
+      return true;
+    } else {
+      layerTarget.type = target.type === 'mousemove' ? 'mouseout' : 'un' + target.type;
+      pickingService.triggerHoverOnLayer(adviceTarget, _objectSpread(_objectSpread({}, layerTarget), {}, {
+        type: 'unpick'
+      }));
+      pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
+      return false;
     }
-  }, {
-    key: "readRasterValue",
-    value: function readRasterValue(layer, bbox, mapService, x, y) {
-      var rasterData = layer.getSource().data.dataArray[0];
-      var _bbox = _slicedToArray(bbox, 4),
-        _bbox$ = _bbox[0],
-        minLng = _bbox$ === void 0 ? 0 : _bbox$,
-        _bbox$2 = _bbox[1],
-        minLat = _bbox$2 === void 0 ? 0 : _bbox$2,
-        _bbox$3 = _bbox[2],
-        maxLng = _bbox$3 === void 0 ? 10 : _bbox$3,
-        _bbox$4 = _bbox[3],
-        maxLat = _bbox$4 === void 0 ? -10 : _bbox$4;
-      var tileXY = mapService.lngLatToContainer([minLng, minLat]);
-      var tileMaxXY = mapService.lngLatToContainer([maxLng, maxLat]);
-      var tilePixelWidth = tileMaxXY.x - tileXY.x;
-      var tilePixelHeight = tileXY.y - tileMaxXY.y;
-      var pos = [(x - tileXY.x) / tilePixelWidth,
-      // x
-      (y - tileMaxXY.y) / tilePixelHeight // y
-      ];
-      var tileWidth = rasterData.width || 1;
-      var tileHeight = rasterData.height || 1;
-      var indexX = Math.floor(pos[0] * tileWidth);
-      var indexY = Math.floor(pos[1] * tileHeight);
-      var index = Math.max(0, indexY - 1) * tileWidth + indexX;
-      var data = rasterData.data[index];
-      return data;
-    }
-  }, {
-    key: "selectFeature",
-    value: function selectFeature(pickedColors) {
-      var layer = this.layer;
-      // @ts-ignore
-      var _pickedColors = _slicedToArray(pickedColors, 3),
-        r = _pickedColors[0],
-        g = _pickedColors[1],
-        b = _pickedColors[2];
-      layer.hooks.beforeSelect.call([r, g, b]);
-    }
-  }, {
-    key: "highlightPickedFeature",
-    value: function highlightPickedFeature(pickedColors) {
-      // @ts-ignore
-      var _pickedColors2 = _slicedToArray(pickedColors, 3),
-        r = _pickedColors2[0],
-        g = _pickedColors2[1],
-        b = _pickedColors2[2];
-      this.layer.hooks.beforeHighlight.call([r, g, b]);
-    }
-  }, {
-    key: "getFeatureById",
-    value: function getFeatureById(pickedFeatureIdx) {
-      return this.layer.getSource().getFeatureById(pickedFeatureIdx);
-    }
-  }]);
-  return BaseLayerPickService;
-}();
-export { BaseLayerPickService as default };
+  }
+  readRasterValue(layer, bbox, mapService, x, y) {
+    const rasterData = layer.getSource().data.dataArray[0];
+    const [minLng = 0, minLat = 0, maxLng = 10, maxLat = -10] = bbox;
+    const tileXY = mapService.lngLatToContainer([minLng, minLat]);
+    const tileMaxXY = mapService.lngLatToContainer([maxLng, maxLat]);
+    const tilePixelWidth = tileMaxXY.x - tileXY.x;
+    const tilePixelHeight = tileXY.y - tileMaxXY.y;
+    const pos = [(x - tileXY.x) / tilePixelWidth,
+    // x
+    (y - tileMaxXY.y) / tilePixelHeight // y
+    ];
+    const tileWidth = rasterData.width || 1;
+    const tileHeight = rasterData.height || 1;
+    const indexX = Math.floor(pos[0] * tileWidth);
+    const indexY = Math.floor(pos[1] * tileHeight);
+    const index = Math.max(0, indexY - 1) * tileWidth + indexX;
+    const data = rasterData.data[index];
+    return data;
+  }
+  selectFeature(pickedColors) {
+    const layer = this.layer;
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    layer.hooks.beforeSelect.call([r, g, b]);
+  }
+  highlightPickedFeature(pickedColors) {
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    this.layer.hooks.beforeHighlight.call([r, g, b]);
+  }
+  getFeatureById(pickedFeatureIdx) {
+    return this.layer.getSource().getFeatureById(pickedFeatureIdx);
+  }
+}

package/es/core/TextureService.js

@@ -1,76 +1,65 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { generateCatRamp, generateColorRamp, generateCustomRamp, generateLinearRamp, generateQuantizeRamp } from '@antv/l7-utils';
-var TextureService = /*#__PURE__*/function () {
-  function TextureService(layer) {
-    _classCallCheck(this, TextureService);
+export default class TextureService {
+  constructor(layer) {
+    _defineProperty(this, "layer", void 0);
+    _defineProperty(this, "rendererService", void 0);
+    _defineProperty(this, "colorTexture", void 0);
+    _defineProperty(this, "key", void 0);
     this.layer = layer;
-    var container = this.layer.getContainer();
+    const container = this.layer.getContainer();
     this.rendererService = container.rendererService;
   }
-  _createClass(TextureService, [{
-    key: "getColorTexture",
-    value: function getColorTexture(colorRamp, domain) {
-      // TODO 支持传入图片
-      var currentkey = this.getTextureKey(colorRamp, domain);
-      if (this.key === currentkey) {
-        return this.colorTexture;
-      } else {
-        this.createColorTexture(colorRamp, domain);
-      }
-      this.key = currentkey;
+  getColorTexture(colorRamp, domain) {
+    // TODO 支持传入图片
+    const currentkey = this.getTextureKey(colorRamp, domain);
+    if (this.key === currentkey) {
       return this.colorTexture;
+    } else {
+      this.createColorTexture(colorRamp, domain);
     }
-  }, {
-    key: "createColorTexture",
-    value: function createColorTexture(colorRamp, domain) {
-      var createTexture2D = this.rendererService.createTexture2D;
-      var imageData = this.getColorRampBar(colorRamp, domain);
-      var texture = createTexture2D({
-        data: new Uint8Array(imageData.data),
-        width: imageData.width,
-        height: imageData.height,
-        flipY: false,
-        unorm: true
-      });
-      this.colorTexture = texture;
-      return texture;
-    }
-  }, {
-    key: "setColorTexture",
-    value: function setColorTexture(texture, colorRamp, domain) {
-      this.key = this.getTextureKey(colorRamp, domain);
-      this.colorTexture = texture;
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      var _this$colorTexture;
-      (_this$colorTexture = this.colorTexture) === null || _this$colorTexture === void 0 || _this$colorTexture.destroy();
-    }
-  }, {
-    key: "getColorRampBar",
-    value: function getColorRampBar(colorRamp, domain) {
-      switch (colorRamp.type) {
-        case 'cat':
-          return generateCatRamp(colorRamp);
-        case 'quantize':
-          return generateQuantizeRamp(colorRamp);
-        case 'custom':
-          return generateCustomRamp(colorRamp, domain);
-        case 'linear':
-          return generateLinearRamp(colorRamp, domain);
-        default:
-          return generateColorRamp(colorRamp);
-      }
-    }
-  }, {
-    key: "getTextureKey",
-    value: function getTextureKey(colorRamp, domain) {
-      var _colorRamp$positions;
-      return "".concat(colorRamp.colors.join('_'), "_").concat(colorRamp === null || colorRamp === void 0 || (_colorRamp$positions = colorRamp.positions) === null || _colorRamp$positions === void 0 ? void 0 : _colorRamp$positions.join('_'), "_").concat(colorRamp.type, "_").concat(domain === null || domain === void 0 ? void 0 : domain.join('_'));
+    this.key = currentkey;
+    return this.colorTexture;
+  }
+  createColorTexture(colorRamp, domain) {
+    const {
+      createTexture2D
+    } = this.rendererService;
+    const imageData = this.getColorRampBar(colorRamp, domain);
+    const texture = createTexture2D({
+      data: new Uint8Array(imageData.data),
+      width: imageData.width,
+      height: imageData.height,
+      flipY: false,
+      unorm: true
+    });
+    this.colorTexture = texture;
+    return texture;
+  }
+  setColorTexture(texture, colorRamp, domain) {
+    this.key = this.getTextureKey(colorRamp, domain);
+    this.colorTexture = texture;
+  }
+  destroy() {
+    var _this$colorTexture;
+    (_this$colorTexture = this.colorTexture) === null || _this$colorTexture === void 0 || _this$colorTexture.destroy();
+  }
+  getColorRampBar(colorRamp, domain) {
+    switch (colorRamp.type) {
+      case 'cat':
+        return generateCatRamp(colorRamp);
+      case 'quantize':
+        return generateQuantizeRamp(colorRamp);
+      case 'custom':
+        return generateCustomRamp(colorRamp, domain);
+      case 'linear':
+        return generateLinearRamp(colorRamp, domain);
+      default:
+        return generateColorRamp(colorRamp);
     }
-  }]);
-  return TextureService;
-}();
-export { TextureService as default };
+  }
+  getTextureKey(colorRamp, domain) {
+    var _colorRamp$positions;
+    return `${colorRamp.colors.join('_')}_${colorRamp === null || colorRamp === void 0 || (_colorRamp$positions = colorRamp.positions) === null || _colorRamp$positions === void 0 ? void 0 : _colorRamp$positions.join('_')}_${colorRamp.type}_${domain === null || domain === void 0 ? void 0 : domain.join('_')}`;
+  }
+}

package/es/core/constant.js

@@ -1,4 +1,4 @@
-export var DefaultUniformStyleValue = {
+export const DefaultUniformStyleValue = {
   opacity: 1,
   stroke: [1, 0, 0, 1],
   offsets: [0, 0],
@@ -7,7 +7,7 @@ export var DefaultUniformStyleValue = {
   strokeOpacity: 1,
   thetaOffset: 0.314
 };
-export var DefaultUniformStyleType = {
+export const DefaultUniformStyleType = {
   opacity: 'float',
   stroke: 'vec4',
   offsets: 'vec2',

package/es/core/interface.js

@@ -1,14 +1,14 @@
-export var lineStyleType = /*#__PURE__*/function (lineStyleType) {
+export let lineStyleType = /*#__PURE__*/function (lineStyleType) {
   lineStyleType[lineStyleType["solid"] = 0] = "solid";
   lineStyleType[lineStyleType["dash"] = 1] = "dash";
   return lineStyleType;
 }({});
-export var LinearDir = /*#__PURE__*/function (LinearDir) {
+export let LinearDir = /*#__PURE__*/function (LinearDir) {
   LinearDir["VERTICAL"] = "vertical";
   LinearDir["HORIZONTAL"] = "horizontal";
   return LinearDir;
 }({});
-export var TextureBlend = /*#__PURE__*/function (TextureBlend) {
+export let TextureBlend = /*#__PURE__*/function (TextureBlend) {
   TextureBlend["NORMAL"] = "normal";
   TextureBlend["REPLACE"] = "replace";
   return TextureBlend;
@@ -17,7 +17,7 @@ export var TextureBlend = /*#__PURE__*/function (TextureBlend) {
  * 基础图层类型定义
  */
 
-export var SizeUnitType = /*#__PURE__*/function (SizeUnitType) {
+export let SizeUnitType = /*#__PURE__*/function (SizeUnitType) {
   SizeUnitType[SizeUnitType["pixel"] = 0] = "pixel";
   SizeUnitType[SizeUnitType["meter"] = 1] = "meter";
   return SizeUnitType;
@@ -25,7 +25,7 @@ export var SizeUnitType = /*#__PURE__*/function (SizeUnitType) {
 
 // 栅格瓦片图层
 
-export var CanvasUpdateType = /*#__PURE__*/function (CanvasUpdateType) {
+export let CanvasUpdateType = /*#__PURE__*/function (CanvasUpdateType) {
   CanvasUpdateType["ALWAYS"] = "always";
   CanvasUpdateType["DRAGEND"] = "dragend";
   return CanvasUpdateType;

package/es/core/line_trangluation.js

@@ -1,5 +1,4 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { getSymbol, lineArrowPath } from "./shape/arrow";
 
 // list all arrow shape
@@ -7,29 +6,30 @@ import { getSymbol, lineArrowPath } from "./shape/arrow";
 // Half Edge
 export function FlowHalfArrowFillTriangulation(feature) {
   // @ts-ignore
-  var coord = feature.coordinates.flat();
-  var tin = 1;
-  var tout = 1.0;
+  const coord = feature.coordinates.flat();
+  const tin = 1;
+  const tout = 1.0;
   return {
-    vertices: [1, 0, 0].concat(_toConsumableArray(coord), [
+    vertices: [1, 0, 0, ...coord,
     // 0
-    1, 2, -3], _toConsumableArray(coord), [
+    1, 2, -3, ...coord,
     // 1
-    1, 1, -3], _toConsumableArray(coord), [
+    1, 1, -3, ...coord,
     // 2
-    0, 1, 0], _toConsumableArray(coord), [
+    0, 1, 0, ...coord,
     // 3
-    0, 0, 0], _toConsumableArray(coord), [
+    0, 0, 0, ...coord,
     // 4
-    1, 0, 0], _toConsumableArray(coord), [
+    1, 0, 0, ...coord,
     // 0
-    1, 2, -3], _toConsumableArray(coord), [
+    1, 2, -3, ...coord,
     // 1
-    1, 1, -3], _toConsumableArray(coord), [
+    1, 1, -3, ...coord,
     // 2
-    0, 1, 0], _toConsumableArray(coord), [
+    0, 1, 0, ...coord,
     // 3
-    0, 0, 0], _toConsumableArray(coord)),
+    0, 0, 0, ...coord // 4
+    ],
     normals: [-tin, 2 * tout, 1,
     // 0
     2 * tout, -tout, 1,
@@ -50,42 +50,37 @@ export function FlowLineTriangulation(feature, symbolOption) {
 }
 export function ArrowLineTriangulation(feature, symbolOption) {
   // @ts-ignore
-  var coord = feature.coordinates.flat();
-  var _ref = symbolOption,
-    _ref$target = _ref.target,
-    target = _ref$target === void 0 ? 'classic' : _ref$target,
-    _ref$source = _ref.source,
-    source = _ref$source === void 0 ? 'circle' : _ref$source;
-  var startSymbol = shape2Vertices(getSymbol(source, 'source'), coord, 0, 0);
-  var linePath = lineArrowPath(coord, startSymbol.vertices.length / 7, symbolOption);
-  var endSymbol = shape2Vertices(getSymbol(target, 'target'), coord, 1, startSymbol.vertices.length / 7 + linePath.vertices.length / 7);
-  var data = {
-    vertices: [].concat(_toConsumableArray(startSymbol.vertices), _toConsumableArray(linePath.vertices), _toConsumableArray(endSymbol.vertices)),
-    indices: [].concat(_toConsumableArray(startSymbol.outLineIndices), _toConsumableArray(linePath.outLineIndices), _toConsumableArray(endSymbol.outLineIndices), _toConsumableArray(startSymbol.indices), _toConsumableArray(linePath.indices), _toConsumableArray(endSymbol.indices)),
-    normals: [].concat(_toConsumableArray(startSymbol.normals), _toConsumableArray(linePath.normals), _toConsumableArray(endSymbol.normals)),
+  const coord = feature.coordinates.flat();
+  const {
+    target = 'classic',
+    source = 'circle'
+  } = symbolOption;
+  const startSymbol = shape2Vertices(getSymbol(source, 'source'), coord, 0, 0);
+  const linePath = lineArrowPath(coord, startSymbol.vertices.length / 7, symbolOption);
+  const endSymbol = shape2Vertices(getSymbol(target, 'target'), coord, 1, startSymbol.vertices.length / 7 + linePath.vertices.length / 7);
+  const data = {
+    vertices: [...startSymbol.vertices, ...linePath.vertices, ...endSymbol.vertices],
+    indices: [...startSymbol.outLineIndices, ...linePath.outLineIndices, ...endSymbol.outLineIndices, ...startSymbol.indices, ...linePath.indices, ...endSymbol.indices],
+    normals: [...startSymbol.normals, ...linePath.normals, ...endSymbol.normals],
     size: 7
   };
   return data;
 }
 // start 0,end 1;
-function shape2Vertices(shape, coord) {
-  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-  var indexOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-  var shapeVertices = [];
-  var vertices = shape.vertices,
-    indices = shape.indices,
-    dimensions = shape.dimensions,
-    outLineIndices = shape.outLineIndices;
-  for (var i = 0; i < vertices.length; i += dimensions) {
-    shapeVertices.push.apply(shapeVertices, [type, vertices[i + 1], vertices[i]].concat(_toConsumableArray(coord)));
+function shape2Vertices(shape, coord, type = 1, indexOffset = 0) {
+  const shapeVertices = [];
+  const {
+    vertices,
+    indices,
+    dimensions,
+    outLineIndices
+  } = shape;
+  for (let i = 0; i < vertices.length; i += dimensions) {
+    shapeVertices.push(type, vertices[i + 1], vertices[i], ...coord);
   }
   return _objectSpread(_objectSpread({}, shape), {}, {
     vertices: shapeVertices,
-    indices: indices.map(function (i) {
-      return i + indexOffset;
-    }),
-    outLineIndices: outLineIndices.map(function (i) {
-      return i + indexOffset;
-    })
+    indices: indices.map(i => i + indexOffset),
+    outLineIndices: outLineIndices.map(i => i + indexOffset)
   });
 }