@antv/l7-layers 2.19.9 → 2.19.11

package/es/core/BaseLayer.d.ts

@@ -127,9 +127,7 @@ export default class BaseLayer<ChildLayerStyleOptions = {}> extends EventEmitter
     init(): Promise<void>;
     log(logType: string, step?: string): void;
     updateModelData(data: IAttributeAndElements): void;
-    createModelData(data: any, option?: ISourceCFG): any;
     setLayerPickService(layerPickService: ILayerPickService): void;
-    calculateEncodeData(data: any, option?: ISourceCFG): IEncodeFeature[] | null;
     /**
      * Model初始化前需要更新Model样式
      */

package/es/core/BaseLayer.js

@@ -13,7 +13,7 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _applyDecoratedDescriptor from "@babel/runtime/helpers/esm/applyDecoratedDescriptor";
 import _initializerWarningHelper from "@babel/runtime/helpers/esm/initializerWarningHelper";
 var _excluded = ["passes"],
-  _excluded2 = ["moduleName", "vertexShader", "fragmentShader", "inject", "triangulation", "segmentNumber"];
+  _excluded2 = ["moduleName", "vertexShader", "fragmentShader", "inject", "triangulation", "styleOption"];
 var _dec, _class, _descriptor;
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
@@ -28,7 +28,6 @@ import Source from '@antv/l7-source';
 import { encodePickingColor, lodashUtil } from '@antv/l7-utils';
 import { EventEmitter } from 'eventemitter3';
 import { BlendTypes } from "../utils/blend";
-import { calculateData } from "../utils/layerData";
 import { createMultiPassRenderer, normalizePasses } from "../utils/multiPassRender";
 import LayerPickService from "./LayerPickService";
 import TextureService from "./TextureService";
@@ -389,40 +388,11 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
         console.warn('data error');
       }
     }
-  }, {
-    key: "createModelData",
-    value: function createModelData(data, option) {
-      var _this$layerModel;
-      if ((_this$layerModel = this.layerModel) !== null && _this$layerModel !== void 0 && _this$layerModel.createModelData) {
-        // 在某些特殊图层中单独构建 attribute & elements
-        return this.layerModel.createModelData(option);
-      }
-      var calEncodeData = this.calculateEncodeData(data, option);
-      var triangulation = this.triangulation;
-      if (calEncodeData && triangulation) {
-        return this.styleAttributeService.createAttributesAndIndices(calEncodeData, triangulation);
-      } else {
-        return {
-          attributes: undefined,
-          elements: undefined
-        };
-      }
-    }
   }, {
     key: "setLayerPickService",
     value: function setLayerPickService(layerPickService) {
       this.layerPickService = layerPickService;
     }
-  }, {
-    key: "calculateEncodeData",
-    value: function calculateEncodeData(data, option) {
-      if (this.inited) {
-        return calculateData(this, this.fontService, this.mapService, this.styleAttributeService, data, option);
-      } else {
-        console.warn('layer not inited!');
-        return null;
-      }
-    }
     /**
      * Model初始化前需要更新Model样式
      */
@@ -568,6 +538,17 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
           }
         });
       }
+      // 兼容 borderColor borderWidth
+      // @ts-ignore
+      if (rest.borderColor) {
+        // @ts-ignore
+        rest.stroke = rest.borderColor;
+      }
+      // @ts-ignore
+      if (rest.borderWidth) {
+        // @ts-ignore
+        rest.strokeWidth = rest.borderWidth;
+      }
 
       // 兼容老版本的写法 ['field, 'value']
       var newOption = rest;
@@ -965,7 +946,7 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
   }, {
     key: "destroy",
     value: function destroy() {
-      var _this$multiPassRender, _this$layerModel2, _this$tileLayer, _this$debugService2;
+      var _this$multiPassRender, _this$layerModel, _this$tileLayer, _this$debugService2;
       var refresh = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
       if (this.isDestroyed) {
         return;
@@ -998,7 +979,7 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
 
       this.hooks.afterDestroy.call();
       // Tip: 清除各个图层自定义的 models 资源
-      (_this$layerModel2 = this.layerModel) === null || _this$layerModel2 === void 0 ? void 0 : _this$layerModel2.clearModels(refresh);
+      (_this$layerModel = this.layerModel) === null || _this$layerModel === void 0 ? void 0 : _this$layerModel.clearModels(refresh);
       (_this$tileLayer = this.tileLayer) === null || _this$tileLayer === void 0 ? void 0 : _this$tileLayer.destroy();
       this.models = [];
       // 清除图层日志（如果有的话：非瓦片相关）
@@ -1025,11 +1006,11 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
   }, {
     key: "clearModels",
     value: function clearModels() {
-      var _this$layerModel3;
+      var _this$layerModel2;
       this.models.forEach(function (model) {
         return model.destroy();
       });
-      (_this$layerModel3 = this.layerModel) === null || _this$layerModel3 === void 0 ? void 0 : _this$layerModel3.clearModels();
+      (_this$layerModel2 = this.layerModel) === null || _this$layerModel2 === void 0 ? void 0 : _this$layerModel2.clearModels();
       this.models = [];
     }
   }, {
@@ -1176,11 +1157,11 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
     value: function () {
       var _buildLayerModel = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
         var _this10 = this;
-        var moduleName, vertexShader, fragmentShader, inject, triangulation, segmentNumber, rest, _this$shaderModuleSer, vs, fs, uniforms, createModel;
+        var moduleName, vertexShader, fragmentShader, inject, triangulation, styleOption, rest, _this$shaderModuleSer, vs, fs, uniforms, createModel;
         return _regeneratorRuntime.wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              moduleName = options.moduleName, vertexShader = options.vertexShader, fragmentShader = options.fragmentShader, inject = options.inject, triangulation = options.triangulation, segmentNumber = options.segmentNumber, rest = _objectWithoutProperties(options, _excluded2);
+              moduleName = options.moduleName, vertexShader = options.vertexShader, fragmentShader = options.fragmentShader, inject = options.inject, triangulation = options.triangulation, styleOption = options.styleOption, rest = _objectWithoutProperties(options, _excluded2);
               this.shaderModuleService.registerModule(moduleName, {
                 vs: vertexShader,
                 fs: fragmentShader,
@@ -1190,7 +1171,7 @@ var BaseLayer = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
               createModel = this.rendererService.createModel;
               return _context3.abrupt("return", new Promise(function (resolve) {
                 // console.log(this.encodedData)
-                var _this10$styleAttribut = _this10.styleAttributeService.createAttributesAndIndices(_this10.encodedData, triangulation, segmentNumber),
+                var _this10$styleAttribut = _this10.styleAttributeService.createAttributesAndIndices(_this10.encodedData, triangulation, styleOption),
                   attributes = _this10$styleAttribut.attributes,
                   elements = _this10$styleAttribut.elements,
                   count = _this10$styleAttribut.count;

package/es/core/BaseModel.js

@@ -13,6 +13,7 @@ import { rgb2arr } from '@antv/l7-utils';
 import { BlendTypes } from "../utils/blend";
 import { getStencil as _getStencil, getStencilMask } from "../utils/stencil";
 import { getCommonStyleAttributeOptions } from "./CommonStyleAttribute";
+import { DefaultUniformStyleType, DefaultUniformStyleValue } from "./constant";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__PURE__*/function () {
   // @lazyInject(TYPES.IIconService)
@@ -207,23 +208,15 @@ var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
     value: function getInject() {
       var encodeStyleAttribute = this.layer.encodeStyleAttribute;
       var str = '';
-      var attrType = {
-        opacity: 'float',
-        stroke: 'vec4',
-        offsets: 'vec2',
-        textOffset: 'vec2',
-        rotation: 'float',
-        extrusionBase: 'float'
-      };
       this.layer.enableShaderEncodeStyles.forEach(function (key) {
         if (encodeStyleAttribute[key]) {
           str += "#define USE_ATTRIBUTE_".concat(key.toUpperCase(), " 0.0; \n\n");
         }
-        str += "\n          #ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n      attribute ").concat(attrType[key], " a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n    #else\n      uniform ").concat(attrType[key], " u_").concat(key, ";\n    #endif\n\n    ");
+        str += "\n          #ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n      attribute ").concat(DefaultUniformStyleType[key], " a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n    #else\n      uniform ").concat(DefaultUniformStyleType[key], " u_").concat(key, ";\n    #endif\n\n    ");
       });
       var innerStr = '';
       this.layer.enableShaderEncodeStyles.forEach(function (key) {
-        innerStr += "\n\n#ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n  ").concat(attrType[key], " ").concat(key, "  = a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n#else\n  ").concat(attrType[key], " ").concat(key, " = u_").concat(key, ";\n#endif\n\n");
+        innerStr += "\n\n#ifdef USE_ATTRIBUTE_".concat(key.toUpperCase(), "\n  ").concat(DefaultUniformStyleType[key], " ").concat(key, "  = a_").concat(key.charAt(0).toUpperCase() + key.slice(1), ";\n#else\n  ").concat(DefaultUniformStyleType[key], " ").concat(key, " = u_").concat(key, ";\n#endif\n\n");
       });
       return {
         'vs:#decl': str,
@@ -238,20 +231,12 @@ var BaseModel = (_dec = lazyInject(TYPES.IGlobalConfigService), (_class = /*#__P
       var _this = this;
       var options = {};
       // TODO: 优化
-
-      var defualtValue = {
-        opacity: 1,
-        stroke: [1, 0, 0, 1],
-        offsets: [0, 0],
-        rotation: 0,
-        extrusionBase: 0
-      };
       this.layer.enableShaderEncodeStyles.forEach(function (key) {
         if (!_this.layer.encodeStyleAttribute[key]) {
           // 没有设置样式映射
           // @ts-ignore
           var keyValue = _this.layer.getLayerConfig()[key];
-          var value = typeof keyValue === 'undefined' ? defualtValue[key] : keyValue;
+          var value = typeof keyValue === 'undefined' ? DefaultUniformStyleValue[key] : keyValue;
           if (key === 'stroke') {
             value = rgb2arr(value);
           }

package/es/core/CommonStyleAttribute.js

@@ -100,6 +100,26 @@ export function getCommonStyleAttributeOptions(name) {
           }
         }
       };
+    case 'thetaOffset':
+      return {
+        name: 'thetaOffset',
+        type: AttributeType.Attribute,
+        descriptor: {
+          name: 'a_ThetaOffset',
+          buffer: {
+            // give the WebGL driver a hint that this buffer may change
+            usage: gl.STATIC_DRAW,
+            data: [],
+            type: gl.FLOAT
+          },
+          size: 1,
+          update: function update(feature) {
+            var _feature$thetaOffset = feature.thetaOffset,
+              op = _feature$thetaOffset === void 0 ? 1 : _feature$thetaOffset;
+            return [op];
+          }
+        }
+      };
     default:
       return undefined;
   }

package/es/core/constant.d.ts

@@ -0,0 +1,6 @@
+export declare const DefaultUniformStyleValue: {
+    [key: string]: any;
+};
+export declare const DefaultUniformStyleType: {
+    [key: string]: any;
+};

package/es/core/constant.js

@@ -0,0 +1,19 @@
+export var DefaultUniformStyleValue = {
+  opacity: 1,
+  stroke: [1, 0, 0, 1],
+  offsets: [0, 0],
+  rotation: 0,
+  extrusionBase: 0,
+  strokeOpacity: 1,
+  thetaOffset: 0.314
+};
+export var DefaultUniformStyleType = {
+  opacity: 'float',
+  stroke: 'vec4',
+  offsets: 'vec2',
+  textOffset: 'vec2',
+  rotation: 'float',
+  extrusionBase: 'float',
+  strokeOpacity: 'float',
+  thetaOffset: 'float'
+};

package/es/core/interface.d.ts

@@ -5,12 +5,6 @@ export declare enum lineStyleType {
     'solid' = 0,
     'dash' = 1
 }
-interface ILineArrow {
-    enable: boolean;
-    arrowWidth: number;
-    arrowHeight: number;
-    tailWidth: number;
-}
 export declare enum LinearDir {
     VERTICAL = "vertical",
     HORIZONTAL = "horizontal"
@@ -31,7 +25,6 @@ export interface IBaseLayerStyleOptions {
     zIndex?: number;
     mask?: boolean;
     maskInside?: boolean;
-    usage?: string;
     color?: string;
     size?: number;
 }
@@ -54,8 +47,10 @@ export interface ILineLayerStyleOptions extends IBaseLayerStyleOptions {
     vertexHeightScale?: number;
     borderWidth?: number;
     borderColor?: string;
+    strokeWidth?: number;
+    storke?: string;
     blur?: [number, number, number];
-    arrow?: ILineArrow;
+    symbol?: ILineSymbol;
     rampColors?: IColorRamp;
     featureId?: string;
     sourceLayer?: string;
@@ -231,15 +226,26 @@ export interface IRasterTerrainLayerStyleOptions extends IBaseRasterLayerStyleOp
     bScaler?: number;
     offset?: number;
 }
+export type ArrowType = 'circle' | 'triangle' | 'rect' | 'diamond' | 'classic' | 'halfTriangle' | 'none';
+export interface IArrowOptions {
+    type: ArrowType;
+    width?: number;
+    height?: number;
+    radius?: number;
+}
+export interface ILineSymbol {
+    source: ArrowType | IArrowOptions;
+    target: ArrowType | IArrowOptions;
+}
 export interface IFlowLineStyleOptions extends IBaseLayerStyleOptions {
     gapWidth?: number;
     offsets?: [number, number];
     stroke?: string;
     strokeOpacity?: number;
     strokeWidth?: number;
+    symbol?: ILineSymbol;
 }
 export interface IStyleEncodeAttributeOptions {
     field: StyleAttributeField;
     values?: StyleAttributeOption;
 }
-export {};

package/es/core/line_trangluation.d.ts

@@ -0,0 +1,19 @@
+import { IEncodeFeature } from '@antv/l7-core';
+export declare function FlowHalfArrowFillTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function FlowLineTriangulation(feature: IEncodeFeature, symbolOption?: unknown): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function ArrowLineTriangulation(feature: IEncodeFeature, symbolOption?: unknown): {
+    vertices: number[];
+    indices: number[];
+    normals: number[];
+    size: number;
+};

package/es/core/line_trangluation.js

@@ -0,0 +1,91 @@
+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
+
+// Half Edge
+export function FlowHalfArrowFillTriangulation(feature) {
+  // @ts-ignore
+  var coord = feature.coordinates.flat();
+  var tin = 1;
+  var tout = 1.0;
+  return {
+    vertices: [1, 0, 0].concat(_toConsumableArray(coord), [
+    // 0
+    1, 2, -3], _toConsumableArray(coord), [
+    // 1
+    1, 1, -3], _toConsumableArray(coord), [
+    // 2
+    0, 1, 0], _toConsumableArray(coord), [
+    // 3
+    0, 0, 0], _toConsumableArray(coord), [
+    // 4
+    1, 0, 0], _toConsumableArray(coord), [
+    // 0
+    1, 2, -3], _toConsumableArray(coord), [
+    // 1
+    1, 1, -3], _toConsumableArray(coord), [
+    // 2
+    0, 1, 0], _toConsumableArray(coord), [
+    // 3
+    0, 0, 0], _toConsumableArray(coord)),
+    normals: [-tin, 2 * tout, 1,
+    // 0
+    2 * tout, -tout, 1,
+    // 1
+    tout, -tout, 1,
+    // 2
+    tout, -tout, 1,
+    // 3
+    -tin, -tout, 1,
+    // 4
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    indices: [0, 1, 2, 0, 2, 3, 0, 3, 4, 5, 6, 7, 5, 7, 8, 5, 8, 9],
+    size: 7
+  };
+}
+export function FlowLineTriangulation(feature, symbolOption) {
+  return symbolOption ? ArrowLineTriangulation(feature, symbolOption) : FlowHalfArrowFillTriangulation(feature);
+}
+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)),
+    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)));
+  }
+  return _objectSpread(_objectSpread({}, shape), {}, {
+    vertices: shapeVertices,
+    indices: indices.map(function (i) {
+      return i + indexOffset;
+    }),
+    outLineIndices: outLineIndices.map(function (i) {
+      return i + indexOffset;
+    })
+  });
+}

package/es/core/shape/arrow.d.ts

@@ -0,0 +1,25 @@
+import { ArrowType, IArrowOptions, ILineSymbol } from '../interface';
+export interface IArrowData {
+    vertices: number[];
+    indices: number[];
+    outLineIndices: number[];
+    dimensions: number;
+    offset?: number[];
+    normals: number[];
+}
+export type arrowPosition = -1 | 1;
+export declare function halfTriangleArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function triangleArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function rectArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function diamondArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function classicArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function circleArraw(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function lineArrowPath(coord: number[], indexOffset: number | undefined, symbol: ILineSymbol): IArrowData;
+export declare function getSymbol(type: ArrowType | IArrowOptions, position: 'source' | 'target'): IArrowData | {
+    vertices: never[];
+    indices: never[];
+    normals: never[];
+    dimensions: number;
+    outLineIndices: never[];
+    outLineNormals: never[];
+};

package/es/core/shape/arrow.js

@@ -0,0 +1,160 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { circle } from "./Path";
+import earcut from 'earcut';
+var maxArrowWidthMap = {
+  circle: 2,
+  triangle: 2,
+  diamond: 4,
+  rect: 2,
+  classic: 3,
+  halfTriangle: 2,
+  'none': 0
+};
+var PathHeight = 1 / 2;
+export function halfTriangleArrow(dir, options) {
+  var _options$width = options.width,
+    width = _options$width === void 0 ? 2 : _options$width,
+    _options$height = options.height,
+    height = _options$height === void 0 ? 1 : _options$height;
+  return {
+    vertices: [0, PathHeight * dir, 1 * dir * width, -(height + PathHeight) * dir, 1 * dir * width, (height - PathHeight) * dir, 0, PathHeight * dir, 1 * dir * width, -(height + PathHeight) * dir, 1 * dir * width, (height - PathHeight) * dir],
+    indices: [3, 4, 5],
+    outLineIndices: [0, 1, 2],
+    normals: [1 * dir, -2 * dir, 1,
+    // y,x
+    -2 * dir, 1.5 * dir, 1, 1 * dir, 1.5 * dir, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+export function triangleArrow(dir, options) {
+  var _options$width2 = options.width,
+    width = _options$width2 === void 0 ? 2 : _options$width2,
+    _options$height2 = options.height,
+    height = _options$height2 === void 0 ? 3 : _options$height2;
+  return {
+    vertices: [0, 0, 1 * dir * width, 1 * height, 1 * dir * width, -1 * height, 0, 0, 1 * dir * width, 1 * height, 1 * dir * width, -1 * height],
+    outLineIndices: [0, 1, 2],
+    indices: [3, 4, 5],
+    normals: [0, -1.5 * dir, 1, 2, 1 * dir, 1, -2, 1 * dir, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+export function rectArrow(dir, options) {
+  var _options$width3 = options.width,
+    width = _options$width3 === void 0 ? 2 : _options$width3,
+    _options$height3 = options.height,
+    height = _options$height3 === void 0 ? 2 : _options$height3;
+  return {
+    vertices: [0, height / 2, dir * width * 1, height / 2, dir * width * 1, -height / 2, 0, -height / 2, 0, height / 2, dir * width * 1, height / 2, dir * width * 1, -height / 2, 0, -height / 2],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+export function diamondArrow(dir, options) {
+  var _options$width4 = options.width,
+    width = _options$width4 === void 0 ? 2 : _options$width4,
+    _options$height4 = options.height,
+    height = _options$height4 === void 0 ? 3 : _options$height4;
+  return {
+    vertices: [0, 0, 1 * width * dir, 0.5 * height, 2 * width * dir, 0, 1 * width * dir, -0.5 * height, 0, 0, 1 * width * dir, 0.5 * height, 2 * width * dir, 0, 1 * width * dir, -0.5 * height],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+export function classicArrow(dir, options) {
+  var _options$width5 = options.width,
+    width = _options$width5 === void 0 ? 2 : _options$width5,
+    _options$height5 = options.height,
+    height = _options$height5 === void 0 ? 3 : _options$height5;
+  return {
+    vertices: [0, 0, 2 * dir * width, 1 * height, 1.5 * dir * width, 0, 2 * dir * width, -1 * height, 0, 0, 2 * dir * width, 1 * height, 1.5 * dir * width, 0, 2 * dir * width, -1 * height],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+export function circleArraw(dir, options) {
+  var _options$width6 = options.width,
+    width = _options$width6 === void 0 ? 2 : _options$width6,
+    _options$height6 = options.height,
+    height = _options$height6 === void 0 ? 2 : _options$height6;
+  var path = circle();
+  var flattengeo = earcut.flatten([path]);
+  var triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  // @ts-ignore
+  var vertice = path.map(function (t) {
+    return [t[0] * width * dir, t[1] * height];
+  }).flat();
+  return {
+    vertices: [].concat(_toConsumableArray(vertice), _toConsumableArray(vertice)),
+    dimensions: 2,
+    indices: triangles.map(function (v) {
+      return v + path.length;
+    }),
+    outLineIndices: triangles,
+    normals: [].concat(_toConsumableArray(path.map(function (t) {
+      return [t[1] * height, t[0] * width * dir, 1];
+    }).flat()), _toConsumableArray(new Array(path.length * 3).fill(0)))
+  };
+}
+export function lineArrowPath(coord) {
+  var indexOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var symbol = arguments.length > 2 ? arguments[2] : undefined;
+  var sourceType = _typeof(symbol['source']) === 'object' ? symbol['source'].type : symbol['source'];
+  var targetType = _typeof(symbol['target']) === 'object' ? symbol['target'].type : symbol['target'];
+  var _ref = _typeof(symbol['source']) === 'object' ? symbol['source'] : {},
+    _ref$width = _ref.width,
+    sourceWidth = _ref$width === void 0 ? sourceType ? maxArrowWidthMap[sourceType] : 0 : _ref$width,
+    _ref$height = _ref.height,
+    sourceHeight = _ref$height === void 0 ? 2 : _ref$height;
+  var _ref2 = _typeof(symbol['target']) === 'object' ? symbol['target'] : {},
+    _ref2$width = _ref2.width,
+    targetWidth = _ref2$width === void 0 ? targetType ? maxArrowWidthMap[targetType] : 0 : _ref2$width,
+    _ref2$height = _ref2.height,
+    targetHeight = _ref2$height === void 0 ? 2 : _ref2$height;
+  return {
+    vertices: [0, PathHeight, 1 * sourceWidth].concat(_toConsumableArray(coord), [1, PathHeight, -1 * targetWidth], _toConsumableArray(coord), [1, -PathHeight, -1 * targetWidth], _toConsumableArray(coord), [0, -PathHeight, 1 * sourceWidth], _toConsumableArray(coord), [0, PathHeight, 1 * sourceWidth], _toConsumableArray(coord), [1, PathHeight, -1 * targetWidth], _toConsumableArray(coord), [1, -PathHeight, -1 * targetWidth], _toConsumableArray(coord), [0, -PathHeight, 1 * sourceWidth], _toConsumableArray(coord)),
+    outLineIndices: [0, 1, 2, 0, 2, 3].map(function (t) {
+      return t + indexOffset;
+    }),
+    indices: [4, 5, 6, 4, 6, 7].map(function (t) {
+      return t + indexOffset;
+    }),
+    normals: [1, -1, 1, 1, 1, 1, -1, 0, 1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+export function getSymbol(type, position) {
+  var shape = _typeof(type) === 'object' ? type.type : type;
+  var dir = position === 'source' ? 1 : -1;
+  var option = _typeof(type) === 'object' ? type : {};
+  switch (shape) {
+    case 'circle':
+      return circleArraw(dir, option);
+    case 'triangle':
+      return triangleArrow(dir, option);
+    case 'diamond':
+      return diamondArrow(dir, option);
+    case 'rect':
+      return rectArrow(dir, option);
+    case 'classic':
+      return classicArrow(dir, option);
+    case 'halfTriangle':
+      return halfTriangleArrow(dir, option);
+    default:
+      return {
+        vertices: [],
+        indices: [],
+        normals: [],
+        dimensions: 2,
+        outLineIndices: [],
+        outLineNormals: []
+      };
+  }
+}

package/es/core/triangulation.d.ts

@@ -48,13 +48,7 @@ export declare function LineTriangulation(feature: IEncodeFeature): {
     size: number;
 };
 export declare function FlowLineFillTriangulation(feature: IEncodeFeature): {
-    vertices: any[];
-    normals: number[];
-    indices: number[];
-    size: number;
-};
-export declare function FlowLineStrokeTriangulation(feature: IEncodeFeature): {
-    vertices: any[];
+    vertices: number[];
     normals: number[];
     indices: number[];
     size: number;
@@ -107,7 +101,7 @@ export declare function RasterImageTriangulation(feature: IEncodeFeature): {
  * @param feature 映射数据
  * @param segNum 弧线线段数
  */
-export declare function LineArcTriangulation(feature: IEncodeFeature, segmentNumber?: number): {
+export declare function LineArcTriangulation(feature: IEncodeFeature, styleOption?: unknown): {
     vertices: number[];
     indices: number[];
     size: number;