@antv/l7-layers 2.21.1 → 2.21.2

package/lib/utils/rampcolor_legend.js

@@ -1,17 +1,18 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.rampColor2legend = rampColor2legend;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 function rampColor2legend(rampColors, name) {
   return {
     type: rampColors.type,
     field: 'value',
-    items: rampColors.positions.map(function (value, index) {
-      return (0, _defineProperty2.default)((0, _defineProperty2.default)({}, name, index >= rampColors.colors.length ? null : rampColors.colors[index]), "value", value);
+    items: rampColors.positions.map((value, index) => {
+      return {
+        [name]: index >= rampColors.colors.length ? null : rampColors.colors[index],
+        value
+      };
     })
   };
 }

package/lib/utils/simpleLine.d.ts

@@ -0,0 +1,23 @@
+import { vec2 } from 'gl-matrix';
+export declare function direction(out: vec2, a: vec2, b: vec2): vec2;
+export default class ExtrudePolyline {
+    complex: {
+        positions: number[];
+        indices: number[];
+        startIndex: number;
+        indexes: number[];
+    };
+    private started;
+    private totalDistance;
+    private currentIndex;
+    constructor();
+    simpleExtrude(points: number[][]): {
+        positions: number[];
+        indices: number[];
+        startIndex: number;
+        indexes: number[];
+    };
+    private simpleSegment;
+    private extrusions;
+    private lineSegmentDistance;
+}

package/lib/utils/simpleLine.js

@@ -6,20 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 exports.direction = direction;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _l7Utils = require("@antv/l7-utils");
 var _glMatrix = require("gl-matrix");
-var lineA = _glMatrix.vec2.create();
+const lineA = _glMatrix.vec2.create();
 function direction(out, a, b) {
   _glMatrix.vec2.sub(out, a, b);
   _glMatrix.vec2.normalize(out, out);
   return out;
 }
-var ExtrudePolyline = exports.default = /*#__PURE__*/function () {
-  function ExtrudePolyline() {
-    (0, _classCallCheck2.default)(this, ExtrudePolyline);
+class ExtrudePolyline {
+  constructor() {
+    (0, _defineProperty2.default)(this, "complex", void 0);
     (0, _defineProperty2.default)(this, "started", false);
     (0, _defineProperty2.default)(this, "totalDistance", 0);
     (0, _defineProperty2.default)(this, "currentIndex", 0);
@@ -30,67 +28,58 @@ var ExtrudePolyline = exports.default = /*#__PURE__*/function () {
       indexes: []
     };
   }
-  (0, _createClass2.default)(ExtrudePolyline, [{
-    key: "simpleExtrude",
-    value: function simpleExtrude(points) {
-      var complex = this.complex;
-      if (points.length <= 1) {
-        return complex;
-      }
-      this.started = false;
-      this.totalDistance = 0;
-      var total = points.length;
-      var count = complex.startIndex;
-      for (var i = 1; i < total; i++) {
-        var last = points[i - 1];
-        var cur = points[i];
-        var amt = this.simpleSegment(complex, count, last, cur);
-        count += amt;
-      }
-      for (var _i = 0; _i < complex.positions.length / 6; _i++) {
-        complex.positions[_i * 6 + 5] = this.totalDistance;
-      }
+  simpleExtrude(points) {
+    const complex = this.complex;
+    if (points.length <= 1) {
       return complex;
     }
-  }, {
-    key: "simpleSegment",
-    value: function simpleSegment(complex, index, last, cur) {
-      var count = 0;
-      var indices = complex.indices;
-      var positions = complex.positions;
-      var flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
-      var flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
-      direction(lineA, flatCur, flatLast);
-      var segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
-      this.totalDistance += segmentDistance;
-      if (!this.started) {
-        this.started = true;
-        this.extrusions(positions, last, this.totalDistance - segmentDistance);
-      }
-      this.extrusions(positions, cur, this.totalDistance);
-      indices.push(index + 0, index + 1, index + 2);
-      indices.push(index + 2, index + 1, index + 3);
-      count += 2;
-      return count;
+    this.started = false;
+    this.totalDistance = 0;
+    const total = points.length;
+    let count = complex.startIndex;
+    for (let i = 1; i < total; i++) {
+      const last = points[i - 1];
+      const cur = points[i];
+      const amt = this.simpleSegment(complex, count, last, cur);
+      count += amt;
     }
-  }, {
-    key: "extrusions",
-    value: function extrusions(positions, point,
-    // 顶点
-    distanceRadio) {
-      positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
-      this.complex.indexes.push(this.currentIndex);
-      positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
-      this.complex.indexes.push(this.currentIndex);
-      this.currentIndex++;
+    for (let i = 0; i < complex.positions.length / 6; i++) {
+      complex.positions[i * 6 + 5] = this.totalDistance;
     }
-  }, {
-    key: "lineSegmentDistance",
-    value: function lineSegmentDistance(b1, a1) {
-      var dx = a1[0] - b1[0];
-      var dy = a1[1] - b1[1];
-      return Math.sqrt(dx * dx + dy * dy);
+    return complex;
+  }
+  simpleSegment(complex, index, last, cur) {
+    let count = 0;
+    const indices = complex.indices;
+    const positions = complex.positions;
+    const flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
+    const flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
+    direction(lineA, flatCur, flatLast);
+    const segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
+    this.totalDistance += segmentDistance;
+    if (!this.started) {
+      this.started = true;
+      this.extrusions(positions, last, this.totalDistance - segmentDistance);
     }
-  }]);
-  return ExtrudePolyline;
-}();
+    this.extrusions(positions, cur, this.totalDistance);
+    indices.push(index + 0, index + 1, index + 2);
+    indices.push(index + 2, index + 1, index + 3);
+    count += 2;
+    return count;
+  }
+  extrusions(positions, point,
+  // 顶点
+  distanceRadio) {
+    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
+    this.complex.indexes.push(this.currentIndex);
+    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
+    this.complex.indexes.push(this.currentIndex);
+    this.currentIndex++;
+  }
+  lineSegmentDistance(b1, a1) {
+    const dx = a1[0] - b1[0];
+    const dy = a1[1] - b1[1];
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+}
+exports.default = ExtrudePolyline;

package/lib/utils/stencil.d.ts

@@ -0,0 +1,7 @@
+import type { IRenderOptions, IStencilOptions, MaskOperationType } from '@antv/l7-core';
+export declare function getStencil(mask: boolean, maskInside: boolean): Partial<IStencilOptions>;
+interface IStencilMaskOptions extends IRenderOptions {
+    maskOperation?: MaskOperationType;
+}
+export declare function getStencilMask(option: Partial<IStencilMaskOptions>): Partial<IStencilOptions>;
+export {};

package/lib/utils/symbol-layout.d.ts

@@ -0,0 +1,43 @@
+interface IPoint {
+    x: number;
+    y: number;
+}
+export type anchorType = 'right' | 'top-right' | 'left' | 'bottom-right' | 'left' | 'top-left' | 'bottom-left' | 'bottom' | 'bottom-right' | 'bottom-left' | 'top' | 'top-right' | 'top-left' | 'center';
+export interface IGlyphQuad {
+    tr: IPoint;
+    tl: IPoint;
+    bl: IPoint;
+    br: IPoint;
+    tex: {
+        x: number;
+        y: number;
+        height: number;
+        width: number;
+        advance: number;
+    };
+    glyphOffset: [number, number];
+}
+/**
+ * 计算文本中每个独立字符相对锚点的位置
+ *
+ * @param {string} text 原始文本
+ * @param {*} glyphs mapping
+ * @param {number} lineHeight 行高
+ * @param {string} textAnchor 文本相对于锚点的位置
+ * @param {string} textJustify 左右对齐
+ * @param {number} spacing 字符间距
+ * @param {[number, number]} translate 文本水平 & 垂直偏移量
+ * @param {[boolean]} isIconFont 是否是 iconfont
+ * @return {boolean|shaping} 每个字符相对于锚点的位置
+ */
+export declare function shapeText(text: string, glyphs: any, lineHeight: number, textAnchor: anchorType, textJustify: string, spacing: number, translate: [number, number] | undefined, isIconFont: boolean): false | {
+    positionedGlyphs: any[];
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    lineCount: number;
+    text: string;
+};
+export declare function getGlyphQuads(shaping: any, textOffset: [number, number] | undefined, alongLine: boolean): IGlyphQuad[];
+export {};

package/lib/utils/symbol-layout.js

@@ -5,17 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getGlyphQuads = getGlyphQuads;
 exports.shapeText = shapeText;
-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; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 /**
  * 返回文本相对锚点位置
  * @param {string} anchor 锚点位置
  * @return {alignment} alignment
  */
 function getAnchorAlignment(anchor) {
-  var horizontalAlign = 0.5;
-  var verticalAlign = 0.5;
+  let horizontalAlign = 0.5;
+  let verticalAlign = 0.5;
   switch (anchor) {
     case 'right':
     case 'top-right':
@@ -45,8 +42,8 @@ function getAnchorAlignment(anchor) {
       verticalAlign = 0.5;
   }
   return {
-    horizontalAlign: horizontalAlign,
-    verticalAlign: verticalAlign
+    horizontalAlign,
+    verticalAlign
   };
 }
 
@@ -55,12 +52,12 @@ function justifyLine(positionedGlyphs, glyphMap, start, end, justify) {
   if (!justify) {
     return;
   }
-  var lastPositionedGlyph = positionedGlyphs[end];
-  var glyph = lastPositionedGlyph.glyph;
+  const lastPositionedGlyph = positionedGlyphs[end];
+  const glyph = lastPositionedGlyph.glyph;
   if (glyph) {
-    var lastAdvance = glyphMap[glyph].advance * lastPositionedGlyph.scale;
-    var lineIndent = (positionedGlyphs[end].x + lastAdvance) * justify;
-    for (var j = start; j <= end; j++) {
+    const lastAdvance = glyphMap[glyph].advance * lastPositionedGlyph.scale;
+    const lineIndent = (positionedGlyphs[end].x + lastAdvance) * justify;
+    for (let j = start; j <= end; j++) {
       positionedGlyphs[j].x -= lineIndent;
     }
   }
@@ -70,39 +67,30 @@ function justifyLine(positionedGlyphs, glyphMap, start, end, justify) {
 // horizontalAlign right=1 left=0 center=0.5
 // verticalAlign right=1 left=0 center=0.5
 function align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lineCount) {
-  var shiftX = (justify - horizontalAlign) * maxLineLength;
-  var shiftY = (-verticalAlign * lineCount + 0.5) * lineHeight;
-  var _iterator = _createForOfIteratorHelper(positionedGlyphs),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var glyphs = _step.value;
-      glyphs.x += shiftX;
-      glyphs.y += shiftY;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  const shiftX = (justify - horizontalAlign) * maxLineLength;
+  const shiftY = (-verticalAlign * lineCount + 0.5) * lineHeight;
+  for (const glyphs of positionedGlyphs) {
+    glyphs.x += shiftX;
+    glyphs.y += shiftY;
   }
 }
 function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustify, spacing) {
   // buffer 为 4
-  var yOffset = -8;
-  var x = 0;
-  var y = yOffset;
-  var maxLineLength = 0;
-  var positionedGlyphs = shaping.positionedGlyphs;
-  var justify = textJustify === 'right' ? 1 : textJustify === 'left' ? 0 : 0.5;
-  var lineStartIndex = positionedGlyphs.length;
-  lines.forEach(function (line) {
-    line.split('').forEach(function (char) {
-      var glyph = glyphMap[char];
-      var baselineOffset = 0;
+  const yOffset = -8;
+  let x = 0;
+  let y = yOffset;
+  let maxLineLength = 0;
+  const positionedGlyphs = shaping.positionedGlyphs;
+  const justify = textJustify === 'right' ? 1 : textJustify === 'left' ? 0 : 0.5;
+  const lineStartIndex = positionedGlyphs.length;
+  lines.forEach(line => {
+    line.split('').forEach(char => {
+      const glyph = glyphMap[char];
+      const baselineOffset = 0;
       if (glyph) {
         positionedGlyphs.push({
           glyph: char,
-          x: x,
+          x,
           y: y + baselineOffset,
           vertical: false,
           // TODO：目前只支持水平方向
@@ -115,20 +103,21 @@ function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustif
 
     // 左右对齐
     if (positionedGlyphs.length !== lineStartIndex) {
-      var lineLength = x - spacing;
+      const lineLength = x - spacing;
       maxLineLength = Math.max(lineLength, maxLineLength);
       justifyLine(positionedGlyphs, glyphMap, lineStartIndex, positionedGlyphs.length - 1, justify);
     }
     x = 0;
     y -= lineHeight + 5;
   });
-  var _getAnchorAlignment = getAnchorAlignment(textAnchor),
-    horizontalAlign = _getAnchorAlignment.horizontalAlign,
-    verticalAlign = _getAnchorAlignment.verticalAlign;
+  const {
+    horizontalAlign,
+    verticalAlign
+  } = getAnchorAlignment(textAnchor);
   align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lines.length);
 
   // 计算包围盒
-  var height = y - yOffset;
+  const height = y - yOffset;
   shaping.top += -verticalAlign * height;
   shaping.bottom = shaping.top - height;
   shaping.left += -horizontalAlign * maxLineLength;
@@ -136,16 +125,16 @@ function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustif
 }
 function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, textJustify, spacing) {
   // buffer 为 4
-  var yOffset = -8;
-  var x = 0;
-  var y = yOffset;
-  var maxLineLength = 0;
-  var positionedGlyphs = shaping.positionedGlyphs;
-  var justify = textJustify === 'right' ? 1 : textJustify === 'left' ? 0 : 0.5;
-  var lineStartIndex = positionedGlyphs.length;
-  iconfonts.forEach(function (iconfont) {
-    var glyph = glyphMap[iconfont];
-    var baselineOffset = 0;
+  const yOffset = -8;
+  let x = 0;
+  let y = yOffset;
+  let maxLineLength = 0;
+  const positionedGlyphs = shaping.positionedGlyphs;
+  const justify = textJustify === 'right' ? 1 : textJustify === 'left' ? 0 : 0.5;
+  const lineStartIndex = positionedGlyphs.length;
+  iconfonts.forEach(iconfont => {
+    const glyph = glyphMap[iconfont];
+    const baselineOffset = 0;
     if (glyph) {
       positionedGlyphs.push({
         glyph: iconfont,
@@ -167,20 +156,21 @@ function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, tex
 
     // 左右对齐
     if (positionedGlyphs.length !== lineStartIndex) {
-      var lineLength = x - spacing;
+      const lineLength = x - spacing;
       maxLineLength = Math.max(lineLength, maxLineLength);
       justifyLine(positionedGlyphs, glyphMap, lineStartIndex, positionedGlyphs.length - 1, justify);
     }
     x = 0;
     y -= lineHeight + 5;
   });
-  var _getAnchorAlignment2 = getAnchorAlignment(textAnchor),
-    horizontalAlign = _getAnchorAlignment2.horizontalAlign,
-    verticalAlign = _getAnchorAlignment2.verticalAlign;
+  const {
+    horizontalAlign,
+    verticalAlign
+  } = getAnchorAlignment(textAnchor);
   align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, iconfonts.length);
 
   // 计算包围盒
-  var height = y - yOffset;
+  const height = y - yOffset;
   shaping.top += -verticalAlign * height;
   shaping.bottom = shaping.top - height;
   shaping.left += -horizontalAlign * maxLineLength;
@@ -200,20 +190,18 @@ function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, tex
  * @param {[boolean]} isIconFont 是否是 iconfont
  * @return {boolean|shaping} 每个字符相对于锚点的位置
  */
-function shapeText(text, glyphs, lineHeight, textAnchor, textJustify, spacing) {
-  var translate = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [0, 0];
-  var isIconFont = arguments.length > 7 ? arguments[7] : undefined;
+function shapeText(text, glyphs, lineHeight, textAnchor, textJustify, spacing, translate = [0, 0], isIconFont) {
   // TODO：处理换行
-  var lines = text.split('\n');
-  var positionedGlyphs = [];
-  var shaping = {
-    positionedGlyphs: positionedGlyphs,
+  const lines = text.split('\n');
+  const positionedGlyphs = [];
+  const shaping = {
+    positionedGlyphs,
     top: translate[1],
     bottom: translate[1],
     left: translate[0],
     right: translate[0],
     lineCount: lines.length,
-    text: text
+    text
   };
   isIconFont ? shapeIconFont(shaping, glyphs, lines, lineHeight, textAnchor, textJustify, spacing) : shapeLines(shaping, glyphs, lines, lineHeight, textAnchor, textJustify, spacing);
   if (!positionedGlyphs.length) {
@@ -221,60 +209,50 @@ function shapeText(text, glyphs, lineHeight, textAnchor, textJustify, spacing) {
   }
   return shaping;
 }
-function getGlyphQuads(shaping) {
-  var textOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0];
-  var alongLine = arguments.length > 2 ? arguments[2] : undefined;
-  var _shaping$positionedGl = shaping.positionedGlyphs,
-    positionedGlyphs = _shaping$positionedGl === void 0 ? [] : _shaping$positionedGl;
-  var quads = [];
-  var _iterator2 = _createForOfIteratorHelper(positionedGlyphs),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var positionedGlyph = _step2.value;
-      var rect = positionedGlyph.metrics;
+function getGlyphQuads(shaping, textOffset = [0, 0], alongLine) {
+  const {
+    positionedGlyphs = []
+  } = shaping;
+  const quads = [];
+  for (const positionedGlyph of positionedGlyphs) {
+    const rect = positionedGlyph.metrics;
 
-      // The rects have an addditional buffer that is not included in their size.
-      var rectBuffer = 4;
-      var halfAdvance = rect.advance * positionedGlyph.scale / 2;
-      var glyphOffset = alongLine ? [positionedGlyph.x + halfAdvance, positionedGlyph.y] : [0, 0];
-      var builtInOffset = alongLine ? [0, 0] : [positionedGlyph.x + halfAdvance + textOffset[0], positionedGlyph.y + textOffset[1]];
-      var x1 = (0 - rectBuffer) * positionedGlyph.scale - halfAdvance + builtInOffset[0];
-      var y1 = (0 - rectBuffer) * positionedGlyph.scale + builtInOffset[1];
-      var x2 = x1 + rect.width * positionedGlyph.scale;
-      var y2 = y1 + rect.height * positionedGlyph.scale;
-      var tl = {
-        x: x1,
-        y: y1
-      };
-      var tr = {
-        x: x2,
-        y: y1
-      };
-      var bl = {
-        x: x1,
-        y: y2
-      };
-      var br = {
-        x: x2,
-        y: y2
-      };
+    // The rects have an addditional buffer that is not included in their size.
+    const rectBuffer = 4;
+    const halfAdvance = rect.advance * positionedGlyph.scale / 2;
+    const glyphOffset = alongLine ? [positionedGlyph.x + halfAdvance, positionedGlyph.y] : [0, 0];
+    const builtInOffset = alongLine ? [0, 0] : [positionedGlyph.x + halfAdvance + textOffset[0], positionedGlyph.y + textOffset[1]];
+    const x1 = (0 - rectBuffer) * positionedGlyph.scale - halfAdvance + builtInOffset[0];
+    const y1 = (0 - rectBuffer) * positionedGlyph.scale + builtInOffset[1];
+    const x2 = x1 + rect.width * positionedGlyph.scale;
+    const y2 = y1 + rect.height * positionedGlyph.scale;
+    const tl = {
+      x: x1,
+      y: y1
+    };
+    const tr = {
+      x: x2,
+      y: y1
+    };
+    const bl = {
+      x: x1,
+      y: y2
+    };
+    const br = {
+      x: x2,
+      y: y2
+    };
 
-      // TODO：处理字符旋转的情况
+    // TODO：处理字符旋转的情况
 
-      quads.push({
-        tl: tl,
-        tr: tr,
-        bl: bl,
-        br: br,
-        tex: rect,
-        glyphOffset: glyphOffset
-      });
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
+    quads.push({
+      tl,
+      tr,
+      bl,
+      br,
+      tex: rect,
+      glyphOffset
+    });
   }
   return quads;
 }

package/lib/wind/index.d.ts

@@ -0,0 +1,11 @@
+import type { IRenderOptions } from '@antv/l7-core';
+import BaseLayer from '../core/BaseLayer';
+import type { IWindLayerStyleOptions } from '../core/interface';
+import type { WindModelType } from './models';
+export default class WindLayer extends BaseLayer<IWindLayerStyleOptions> {
+    type: string;
+    buildModels(): Promise<void>;
+    renderModels(options?: Partial<IRenderOptions>): this;
+    protected getDefaultConfig(): {};
+    getModelType(): WindModelType;
+}