@antv/l7-layers 2.21.1 → 2.21.2

package/lib/core/interface.d.ts

@@ -0,0 +1,282 @@
+import type { IAnimateOption, IMapService, ITexture2D, StyleAttributeField, StyleAttributeOption } from '@antv/l7-core';
+import type { IColorRamp } from '@antv/l7-utils';
+import type { CanvasModelType } from '../canvas/models';
+import type { anchorType } from '../utils/symbol-layout';
+export declare enum lineStyleType {
+    'solid' = 0,
+    'dash' = 1
+}
+export declare enum LinearDir {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal"
+}
+export declare enum TextureBlend {
+    NORMAL = "normal",
+    REPLACE = "replace"
+}
+/**
+ * 基础图层类型定义
+ */
+export interface IBaseLayerStyleOptions {
+    opacity?: number;
+    depth?: boolean;
+    blend?: string;
+    raisingHeight?: number;
+    heightfixed?: boolean;
+    zIndex?: number;
+    mask?: boolean;
+    maskInside?: boolean;
+    color?: string;
+    size?: number;
+}
+export interface ILineLayerStyleOptions extends IBaseLayerStyleOptions {
+    tileOrigin?: number[];
+    coord?: string;
+    lineType?: keyof typeof lineStyleType;
+    dashArray?: [number, number];
+    segmentNumber?: number;
+    forward?: boolean;
+    lineTexture?: boolean;
+    iconStep?: number;
+    iconStepCount?: number;
+    textureBlend?: TextureBlend;
+    linearDir?: LinearDir;
+    sourceColor?: string;
+    targetColor?: string;
+    thetaOffset?: number;
+    globalArcHeight?: number;
+    vertexHeightScale?: number;
+    borderWidth?: number;
+    borderColor?: string;
+    strokeWidth?: number;
+    storke?: string;
+    blur?: [number, number, number];
+    symbol?: ILineSymbol;
+    rampColors?: IColorRamp;
+    featureId?: string;
+    sourceLayer?: string;
+    enablePicking?: boolean;
+    workerEnabled?: boolean;
+}
+export declare enum SizeUnitType {
+    pixel = 0,
+    meter = 1
+}
+export interface IPointLayerStyleOptions extends IBaseLayerStyleOptions {
+    tileOrigin?: number[];
+    coord?: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    stroke: string;
+    blur?: number;
+    billboard?: boolean;
+    textOffset?: [number, number];
+    textAnchor?: anchorType;
+    spacing?: number;
+    padding?: [number, number];
+    halo?: number;
+    gamma?: number;
+    fontWeight?: string;
+    fontFamily?: string;
+    textAllowOverlap?: boolean;
+    pickLight?: boolean;
+    sourceColor?: string;
+    targetColor?: string;
+    opacityLinear?: {
+        enable: boolean;
+        dir: string;
+    };
+    lightEnable: boolean;
+    offsets?: [number, number];
+    unit?: SizeUnitType;
+    rotation?: number;
+    speed?: number;
+    featureId?: string;
+    sourceLayer?: string;
+}
+export interface IPolygonLayerStyleOptions extends IBaseLayerStyleOptions {
+    tileOrigin?: number[];
+    coord?: string;
+    opacityLinear?: {
+        enable: boolean;
+        dir: string;
+    };
+    topsurface?: boolean;
+    sidesurface?: boolean;
+    mapTexture?: string;
+    sourceColor?: string;
+    targetColor?: string;
+    pickLight: boolean;
+    waterTexture?: string;
+    speed?: number;
+    watercolor?: string;
+    watercolor2?: string;
+    featureId?: string;
+    sourceLayer?: string;
+}
+export interface IPolygonExtrusionStyleOptions {
+    opacity: number;
+    extrusionBase: number;
+}
+export interface IRasterTileLayerStyleOptions extends IBaseLayerStyleOptions {
+    opacity: number;
+}
+export interface IMaskLayerStyleOptions extends IBaseLayerStyleOptions {
+    opacity: number;
+    color: string;
+    sourceLayer?: string;
+}
+export interface IWindLayerStyleOptions extends IBaseLayerStyleOptions {
+    uMin?: number;
+    uMax?: number;
+    vMin?: number;
+    vMax?: number;
+    fadeOpacity?: number;
+    speedFactor?: number;
+    dropRate?: number;
+    dropRateBump?: number;
+    numParticles?: number;
+    rampColors?: {
+        [key: number]: string;
+    };
+    sizeScale?: number;
+}
+export interface IImageLayerStyleOptions extends IBaseLayerStyleOptions {
+    domain?: [number, number];
+    noDataValue?: number;
+    clampLow?: boolean;
+    clampHigh?: boolean;
+    rampColors?: IColorRamp;
+    colorTexture?: ITexture2D;
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    gamma?: number;
+}
+export interface ICityBuildLayerStyleOptions {
+    opacity: number;
+    baseColor: string;
+    brightColor: string;
+    windowColor: string;
+    time: number;
+    sweep: {
+        enable: boolean;
+        sweepRadius: number;
+        sweepColor: string;
+        sweepSpeed: number;
+        sweepCenter?: [number, number];
+    };
+}
+export interface IGeometryLayerStyleOptions extends IBaseLayerStyleOptions {
+    mapTexture?: string;
+    terrainTexture?: string;
+    center?: [number, number];
+    width?: number;
+    height?: number;
+    widthSegments?: number;
+    heightSegments?: number;
+    terrainClipHeight?: number;
+    rgb2height?: (r: number, g: number, b: number) => number;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    drawCanvas?: (canvas: HTMLCanvasElement) => void;
+    spriteAnimate?: string;
+    spriteRadius?: number;
+    spriteCount?: number;
+    spriteSpeed?: number;
+    spriteTop?: number;
+    spriteBottom?: number;
+    spriteUpdate?: number;
+    spriteScale?: number;
+    animateOption?: IAnimateOption;
+}
+export declare enum CanvasUpdateType {
+    'ALWAYS' = "always",
+    'DRAGEND' = "dragend"
+}
+export interface IDrawingOnCanvas {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    mapService: IMapService;
+    size: [number, number];
+}
+export interface ICanvasLayerRenderParams {
+    canvas: HTMLCanvasElement;
+    ctx: RenderingContext;
+    container: {
+        width: number;
+        height: number;
+        bounds: [[number, number], [number, number]];
+    };
+    size: [number, number];
+    utils: {
+        lngLatToContainer: IMapService['lngLatToContainer'];
+    };
+    mapService: IMapService;
+}
+export interface ICanvasLayerOptions {
+    zIndex?: number;
+    contextType?: CanvasModelType;
+    getContext?: (canvas: HTMLCanvasElement) => RenderingContext;
+    trigger?: 'end' | 'change';
+    /**
+     * @deprecated
+     * @alias trigger
+     */
+    update?: CanvasUpdateType | string;
+    draw?: (renderParams: ICanvasLayerRenderParams) => void;
+    /**
+     * @deprecated
+     * @alias draw
+     */
+    drawingOnCanvas?: (renderParams: ICanvasLayerRenderParams) => void;
+}
+export interface IHeatMapLayerStyleOptions extends IBaseLayerStyleOptions {
+    intensity: number;
+    radius: number;
+    angle: number;
+    rampColors: IColorRamp;
+    coverage?: number;
+}
+export interface IBaseRasterLayerStyleOptions extends IBaseLayerStyleOptions {
+    colorTexture?: ITexture2D;
+    domain: [number, number];
+    noDataValue: number;
+    clampLow: boolean;
+    clampHigh: boolean;
+    rampColors: IColorRamp;
+}
+export interface IRasterLayerStyleOptions extends IBaseRasterLayerStyleOptions {
+    channelRMax?: number;
+    channelGMax?: number;
+    channelBMax?: number;
+}
+export interface IRasterTerrainLayerStyleOptions extends IBaseRasterLayerStyleOptions {
+    rScaler?: number;
+    gScaler?: number;
+    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;
+}

package/lib/core/interface.js

@@ -4,17 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.lineStyleType = exports.TextureBlend = exports.SizeUnitType = exports.LinearDir = exports.CanvasUpdateType = void 0;
-var lineStyleType = exports.lineStyleType = /*#__PURE__*/function (lineStyleType) {
+let lineStyleType = exports.lineStyleType = /*#__PURE__*/function (lineStyleType) {
   lineStyleType[lineStyleType["solid"] = 0] = "solid";
   lineStyleType[lineStyleType["dash"] = 1] = "dash";
   return lineStyleType;
 }({});
-var LinearDir = exports.LinearDir = /*#__PURE__*/function (LinearDir) {
+let LinearDir = exports.LinearDir = /*#__PURE__*/function (LinearDir) {
   LinearDir["VERTICAL"] = "vertical";
   LinearDir["HORIZONTAL"] = "horizontal";
   return LinearDir;
 }({});
-var TextureBlend = exports.TextureBlend = /*#__PURE__*/function (TextureBlend) {
+let TextureBlend = exports.TextureBlend = /*#__PURE__*/function (TextureBlend) {
   TextureBlend["NORMAL"] = "normal";
   TextureBlend["REPLACE"] = "replace";
   return TextureBlend;
@@ -22,12 +22,12 @@ var TextureBlend = exports.TextureBlend = /*#__PURE__*/function (TextureBlend) {
 /**
  * 基础图层类型定义
  */
-var SizeUnitType = exports.SizeUnitType = /*#__PURE__*/function (SizeUnitType) {
+let SizeUnitType = exports.SizeUnitType = /*#__PURE__*/function (SizeUnitType) {
   SizeUnitType[SizeUnitType["pixel"] = 0] = "pixel";
   SizeUnitType[SizeUnitType["meter"] = 1] = "meter";
   return SizeUnitType;
 }({}); // 栅格瓦片图层
-var CanvasUpdateType = exports.CanvasUpdateType = /*#__PURE__*/function (CanvasUpdateType) {
+let CanvasUpdateType = exports.CanvasUpdateType = /*#__PURE__*/function (CanvasUpdateType) {
   CanvasUpdateType["ALWAYS"] = "always";
   CanvasUpdateType["DRAGEND"] = "dragend";
   return CanvasUpdateType;

package/lib/core/line_trangluation.d.ts

@@ -0,0 +1,19 @@
+import type { 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/lib/core/line_trangluation.js

@@ -8,36 +8,36 @@ exports.ArrowLineTriangulation = ArrowLineTriangulation;
 exports.FlowHalfArrowFillTriangulation = FlowHalfArrowFillTriangulation;
 exports.FlowLineTriangulation = FlowLineTriangulation;
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _arrow = require("./shape/arrow");
 // list all arrow shape
 
 // Half Edge
 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((0, _toConsumableArray2.default)(coord), [
+    vertices: [1, 0, 0, ...coord,
     // 0
-    1, 2, -3], (0, _toConsumableArray2.default)(coord), [
+    1, 2, -3, ...coord,
     // 1
-    1, 1, -3], (0, _toConsumableArray2.default)(coord), [
+    1, 1, -3, ...coord,
     // 2
-    0, 1, 0], (0, _toConsumableArray2.default)(coord), [
+    0, 1, 0, ...coord,
     // 3
-    0, 0, 0], (0, _toConsumableArray2.default)(coord), [
+    0, 0, 0, ...coord,
     // 4
-    1, 0, 0], (0, _toConsumableArray2.default)(coord), [
+    1, 0, 0, ...coord,
     // 0
-    1, 2, -3], (0, _toConsumableArray2.default)(coord), [
+    1, 2, -3, ...coord,
     // 1
-    1, 1, -3], (0, _toConsumableArray2.default)(coord), [
+    1, 1, -3, ...coord,
     // 2
-    0, 1, 0], (0, _toConsumableArray2.default)(coord), [
+    0, 1, 0, ...coord,
     // 3
-    0, 0, 0], (0, _toConsumableArray2.default)(coord)),
+    0, 0, 0, ...coord // 4
+    ],
     normals: [-tin, 2 * tout, 1,
     // 0
     2 * tout, -tout, 1,
@@ -58,42 +58,37 @@ function FlowLineTriangulation(feature, symbolOption) {
 }
 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((0, _arrow.getSymbol)(source, 'source'), coord, 0, 0);
-  var linePath = (0, _arrow.lineArrowPath)(coord, startSymbol.vertices.length / 7, symbolOption);
-  var endSymbol = shape2Vertices((0, _arrow.getSymbol)(target, 'target'), coord, 1, startSymbol.vertices.length / 7 + linePath.vertices.length / 7);
-  var data = {
-    vertices: [].concat((0, _toConsumableArray2.default)(startSymbol.vertices), (0, _toConsumableArray2.default)(linePath.vertices), (0, _toConsumableArray2.default)(endSymbol.vertices)),
-    indices: [].concat((0, _toConsumableArray2.default)(startSymbol.outLineIndices), (0, _toConsumableArray2.default)(linePath.outLineIndices), (0, _toConsumableArray2.default)(endSymbol.outLineIndices), (0, _toConsumableArray2.default)(startSymbol.indices), (0, _toConsumableArray2.default)(linePath.indices), (0, _toConsumableArray2.default)(endSymbol.indices)),
-    normals: [].concat((0, _toConsumableArray2.default)(startSymbol.normals), (0, _toConsumableArray2.default)(linePath.normals), (0, _toConsumableArray2.default)(endSymbol.normals)),
+  const coord = feature.coordinates.flat();
+  const {
+    target = 'classic',
+    source = 'circle'
+  } = symbolOption;
+  const startSymbol = shape2Vertices((0, _arrow.getSymbol)(source, 'source'), coord, 0, 0);
+  const linePath = (0, _arrow.lineArrowPath)(coord, startSymbol.vertices.length / 7, symbolOption);
+  const endSymbol = shape2Vertices((0, _arrow.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((0, _toConsumableArray2.default)(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 (0, _objectSpread2.default)((0, _objectSpread2.default)({}, 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)
   });
 }

package/lib/core/schema.d.ts

@@ -0,0 +1,27 @@
+/**
+ * BaseLayer Schema
+ */
+declare const _default: {
+    properties: {
+        enablePicking: {
+            type: string;
+        };
+        enableHighlight: {
+            type: string;
+        };
+        highlightColor: {
+            oneOf: ({
+                type: string;
+                items: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            } | {
+                type: string;
+                items?: undefined;
+            })[];
+        };
+    };
+};
+export default _default;

package/lib/core/shape/Path.d.ts

@@ -0,0 +1,39 @@
+export type IPosition = [number, number, number] | [number, number];
+export type IPath = IPosition[];
+export declare enum ShapeType3D {
+    CYLINDER = "cylinder",
+    SQUARECOLUMN = "squareColumn",
+    TRIANGLECOLUMN = "triangleColumn",
+    HEXAGONCOLUMN = "hexagonColumn",
+    PENTAGONCOLUMN = "pentagonColumn"
+}
+export declare enum ShapeType2D {
+    CIRCLE = "circle",
+    SQUARE = "square",
+    TRIANGLE = "triangle",
+    HEXAGON = "hexagon",
+    PENTAGON = "pentagon"
+}
+/**
+ * 生成规则多边形顶点个数
+ * @param pointCount  顶点个数 3 => 三角形
+ * @param start 顶点起始角度 调整图形的方向
+ */
+export declare function polygonPath(pointCount: number, start?: number): IPath;
+export declare function circle(): IPath;
+export declare function square(): IPath;
+export declare function triangle(): IPath;
+export declare function hexagon(): IPath;
+export declare function pentagon(): IPath;
+export declare const geometryShape: {
+    circle: typeof circle;
+    hexagon: typeof hexagon;
+    triangle: typeof triangle;
+    square: typeof square;
+    pentagon: typeof pentagon;
+    cylinder: typeof circle;
+    hexagonColumn: typeof hexagon;
+    triangleColumn: typeof triangle;
+    squareColumn: typeof square;
+    pentagonColumn: typeof pentagon;
+};

package/lib/core/shape/Path.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -12,8 +11,7 @@ exports.pentagon = pentagon;
 exports.polygonPath = polygonPath;
 exports.square = square;
 exports.triangle = triangle;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var ShapeType3D = exports.ShapeType3D = /*#__PURE__*/function (ShapeType3D) {
+let ShapeType3D = exports.ShapeType3D = /*#__PURE__*/function (ShapeType3D) {
   ShapeType3D["CYLINDER"] = "cylinder";
   ShapeType3D["SQUARECOLUMN"] = "squareColumn";
   ShapeType3D["TRIANGLECOLUMN"] = "triangleColumn";
@@ -21,7 +19,7 @@ var ShapeType3D = exports.ShapeType3D = /*#__PURE__*/function (ShapeType3D) {
   ShapeType3D["PENTAGONCOLUMN"] = "pentagonColumn";
   return ShapeType3D;
 }({});
-var ShapeType2D = exports.ShapeType2D = /*#__PURE__*/function (ShapeType2D) {
+let ShapeType2D = exports.ShapeType2D = /*#__PURE__*/function (ShapeType2D) {
   ShapeType2D["CIRCLE"] = "circle";
   ShapeType2D["SQUARE"] = "square";
   ShapeType2D["TRIANGLE"] = "triangle";
@@ -34,16 +32,15 @@ var ShapeType2D = exports.ShapeType2D = /*#__PURE__*/function (ShapeType2D) {
  * @param pointCount  顶点个数 3 => 三角形
  * @param start 顶点起始角度 调整图形的方向
  */
-function polygonPath(pointCount) {
-  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var step = Math.PI * 2 / pointCount;
-  var line = [];
-  for (var i = 0; i < pointCount; i++) {
+function polygonPath(pointCount, start = 0) {
+  const step = Math.PI * 2 / pointCount;
+  const line = [];
+  for (let i = 0; i < pointCount; i++) {
     line.push(step * i + start * Math.PI / 12);
   }
-  var path = line.map(function (t) {
-    var x = Math.sin(t + Math.PI / 4);
-    var y = Math.cos(t + Math.PI / 4);
+  const path = line.map(t => {
+    const x = Math.sin(t + Math.PI / 4);
+    const y = Math.cos(t + Math.PI / 4);
     return [x, y, 0];
   });
   // path.push(path[0]);
@@ -64,4 +61,15 @@ function hexagon() {
 function pentagon() {
   return polygonPath(5);
 }
-var geometryShape = exports.geometryShape = (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, ShapeType2D.CIRCLE, circle), ShapeType2D.HEXAGON, hexagon), ShapeType2D.TRIANGLE, triangle), ShapeType2D.SQUARE, square), ShapeType2D.PENTAGON, pentagon), ShapeType3D.CYLINDER, circle), ShapeType3D.HEXAGONCOLUMN, hexagon), ShapeType3D.TRIANGLECOLUMN, triangle), ShapeType3D.SQUARECOLUMN, square), ShapeType3D.PENTAGONCOLUMN, pentagon);
+const geometryShape = exports.geometryShape = {
+  [ShapeType2D.CIRCLE]: circle,
+  [ShapeType2D.HEXAGON]: hexagon,
+  [ShapeType2D.TRIANGLE]: triangle,
+  [ShapeType2D.SQUARE]: square,
+  [ShapeType2D.PENTAGON]: pentagon,
+  [ShapeType3D.CYLINDER]: circle,
+  [ShapeType3D.HEXAGONCOLUMN]: hexagon,
+  [ShapeType3D.TRIANGLECOLUMN]: triangle,
+  [ShapeType3D.SQUARECOLUMN]: square,
+  [ShapeType3D.PENTAGONCOLUMN]: pentagon
+};

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

@@ -0,0 +1,25 @@
+import type { 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[];
+};