@antv/l7-layers 2.21.1 → 2.21.2

package/lib/utils/grid-index.d.ts

@@ -0,0 +1,28 @@
+type CallBack = (...args: any[]) => any;
+/**
+ * 网格索引，相比 @mapbox/grid-index，在简单计算碰撞检测结果时效率更高
+ * @see https://zhuanlan.zhihu.com/p/74373214
+ */
+declare class GridIndex {
+    private boxCells;
+    private xCellCount;
+    private yCellCount;
+    private boxKeys;
+    private bboxes;
+    private width;
+    private height;
+    private xScale;
+    private yScale;
+    private boxUid;
+    constructor(width: number, height: number, cellSize: number);
+    insert(key: any, x1: number, y1: number, x2: number, y2: number): void;
+    query(x1: number, y1: number, x2: number, y2: number, predicate?: CallBack): boolean | any[];
+    hitTest(x1: number, y1: number, x2: number, y2: number, predicate?: CallBack): boolean | any[];
+    private insertBoxCell;
+    private queryHitTest;
+    private queryCell;
+    private forEachCell;
+    private convertToXCellCoord;
+    private convertToYCellCoord;
+}
+export default GridIndex;

package/lib/utils/grid-index.js

@@ -5,24 +5,27 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-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; }
 /**
  * 网格索引，相比 @mapbox/grid-index，在简单计算碰撞检测结果时效率更高
  * @see https://zhuanlan.zhihu.com/p/74373214
  */
-var GridIndex = /*#__PURE__*/function () {
-  function GridIndex(width, height, cellSize) {
-    (0, _classCallCheck2.default)(this, GridIndex);
+class GridIndex {
+  constructor(width, height, cellSize) {
     (0, _defineProperty2.default)(this, "boxCells", []);
-    var boxCells = this.boxCells;
+    (0, _defineProperty2.default)(this, "xCellCount", void 0);
+    (0, _defineProperty2.default)(this, "yCellCount", void 0);
+    (0, _defineProperty2.default)(this, "boxKeys", void 0);
+    (0, _defineProperty2.default)(this, "bboxes", void 0);
+    (0, _defineProperty2.default)(this, "width", void 0);
+    (0, _defineProperty2.default)(this, "height", void 0);
+    (0, _defineProperty2.default)(this, "xScale", void 0);
+    (0, _defineProperty2.default)(this, "yScale", void 0);
+    (0, _defineProperty2.default)(this, "boxUid", void 0);
+    const boxCells = this.boxCells;
     this.xCellCount = Math.ceil(width / cellSize);
     this.yCellCount = Math.ceil(height / cellSize);
-    for (var i = 0; i < this.xCellCount * this.yCellCount; i++) {
+    for (let i = 0; i < this.xCellCount * this.yCellCount; i++) {
       boxCells.push([]);
     }
     this.boxKeys = [];
@@ -33,129 +36,100 @@ var GridIndex = /*#__PURE__*/function () {
     this.yScale = this.yCellCount / height;
     this.boxUid = 0;
   }
-  (0, _createClass2.default)(GridIndex, [{
-    key: "insert",
-    value: function insert(key, x1, y1, x2, y2) {
-      this.forEachCell(x1, y1, x2, y2, this.insertBoxCell, this.boxUid++);
-      this.boxKeys.push(key);
-      this.bboxes.push(x1);
-      this.bboxes.push(y1);
-      this.bboxes.push(x2);
-      this.bboxes.push(y2);
-    }
-  }, {
-    key: "query",
-    value: function query(x1, y1, x2, y2, predicate) {
-      return this.queryHitTest(x1, y1, x2, y2, false, predicate);
-    }
-  }, {
-    key: "hitTest",
-    value: function hitTest(x1, y1, x2, y2, predicate) {
-      return this.queryHitTest(x1, y1, x2, y2, true, predicate);
-    }
-  }, {
-    key: "insertBoxCell",
-    value: function insertBoxCell(x1, y1, x2, y2, cellIndex, uid) {
-      this.boxCells[cellIndex].push(uid);
+  insert(key, x1, y1, x2, y2) {
+    this.forEachCell(x1, y1, x2, y2, this.insertBoxCell, this.boxUid++);
+    this.boxKeys.push(key);
+    this.bboxes.push(x1);
+    this.bboxes.push(y1);
+    this.bboxes.push(x2);
+    this.bboxes.push(y2);
+  }
+  query(x1, y1, x2, y2, predicate) {
+    return this.queryHitTest(x1, y1, x2, y2, false, predicate);
+  }
+  hitTest(x1, y1, x2, y2, predicate) {
+    return this.queryHitTest(x1, y1, x2, y2, true, predicate);
+  }
+  insertBoxCell(x1, y1, x2, y2, cellIndex, uid) {
+    this.boxCells[cellIndex].push(uid);
+  }
+  queryHitTest(x1, y1, x2, y2, hitTest, predicate) {
+    if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+      return hitTest ? false : [];
     }
-  }, {
-    key: "queryHitTest",
-    value: function queryHitTest(x1, y1, x2, y2, hitTest, predicate) {
-      if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
-        return hitTest ? false : [];
+    const result = [];
+    if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
+      // 这一步是高效的关键，后续精确碰撞检测结果在计算文本可见性时并不需要
+      if (hitTest) {
+        return true;
       }
-      var result = [];
-      if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
-        // 这一步是高效的关键，后续精确碰撞检测结果在计算文本可见性时并不需要
-        if (hitTest) {
-          return true;
-        }
-        for (var boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
-          result.push({
-            key: this.boxKeys[boxUid],
-            x1: this.bboxes[boxUid * 4],
-            y1: this.bboxes[boxUid * 4 + 1],
-            x2: this.bboxes[boxUid * 4 + 2],
-            y2: this.bboxes[boxUid * 4 + 3]
-          });
-        }
-        return predicate ? result.filter(predicate) : result;
+      for (let boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
+        result.push({
+          key: this.boxKeys[boxUid],
+          x1: this.bboxes[boxUid * 4],
+          y1: this.bboxes[boxUid * 4 + 1],
+          x2: this.bboxes[boxUid * 4 + 2],
+          y2: this.bboxes[boxUid * 4 + 3]
+        });
       }
-      var queryArgs = {
-        hitTest: hitTest,
-        seenUids: {
-          box: {},
-          circle: {}
-        }
-      };
-      this.forEachCell(x1, y1, x2, y2, this.queryCell, result, queryArgs, predicate);
-      return hitTest ? result.length > 0 : result;
+      return predicate ? result.filter(predicate) : result;
     }
-  }, {
-    key: "queryCell",
-    value: function queryCell(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
-      var seenUids = queryArgs.seenUids;
-      var boxCell = this.boxCells[cellIndex];
-      if (boxCell !== null) {
-        var bboxes = this.bboxes;
-        var _iterator = _createForOfIteratorHelper(boxCell),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var boxUid = _step.value;
-            if (!seenUids.box[boxUid]) {
-              seenUids.box[boxUid] = true;
-              var offset = boxUid * 4;
-              if (x1 <= bboxes[offset + 2] && y1 <= bboxes[offset + 3] && x2 >= bboxes[offset + 0] && y2 >= bboxes[offset + 1] && (!predicate || predicate(this.boxKeys[boxUid]))) {
-                if (queryArgs.hitTest) {
-                  result.push(true);
-                  return true;
-                }
-                result.push({
-                  key: this.boxKeys[boxUid],
-                  x1: bboxes[offset],
-                  y1: bboxes[offset + 1],
-                  x2: bboxes[offset + 2],
-                  y2: bboxes[offset + 3]
-                });
-              }
+    const queryArgs = {
+      hitTest,
+      seenUids: {
+        box: {},
+        circle: {}
+      }
+    };
+    this.forEachCell(x1, y1, x2, y2, this.queryCell, result, queryArgs, predicate);
+    return hitTest ? result.length > 0 : result;
+  }
+  queryCell(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
+    const seenUids = queryArgs.seenUids;
+    const boxCell = this.boxCells[cellIndex];
+    if (boxCell !== null) {
+      const bboxes = this.bboxes;
+      for (const boxUid of boxCell) {
+        if (!seenUids.box[boxUid]) {
+          seenUids.box[boxUid] = true;
+          const offset = boxUid * 4;
+          if (x1 <= bboxes[offset + 2] && y1 <= bboxes[offset + 3] && x2 >= bboxes[offset + 0] && y2 >= bboxes[offset + 1] && (!predicate || predicate(this.boxKeys[boxUid]))) {
+            if (queryArgs.hitTest) {
+              result.push(true);
+              return true;
             }
+            result.push({
+              key: this.boxKeys[boxUid],
+              x1: bboxes[offset],
+              y1: bboxes[offset + 1],
+              x2: bboxes[offset + 2],
+              y2: bboxes[offset + 3]
+            });
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
       }
-      return false;
     }
-  }, {
-    key: "forEachCell",
-    value: function forEachCell(x1, y1, x2, y2, fn, arg1, arg2, predicate) {
-      var cx1 = this.convertToXCellCoord(x1);
-      var cy1 = this.convertToYCellCoord(y1);
-      var cx2 = this.convertToXCellCoord(x2);
-      var cy2 = this.convertToYCellCoord(y2);
-      for (var x = cx1; x <= cx2; x++) {
-        for (var y = cy1; y <= cy2; y++) {
-          var cellIndex = this.xCellCount * y + x;
-          if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) {
-            return;
-          }
+    return false;
+  }
+  forEachCell(x1, y1, x2, y2, fn, arg1, arg2, predicate) {
+    const cx1 = this.convertToXCellCoord(x1);
+    const cy1 = this.convertToYCellCoord(y1);
+    const cx2 = this.convertToXCellCoord(x2);
+    const cy2 = this.convertToYCellCoord(y2);
+    for (let x = cx1; x <= cx2; x++) {
+      for (let y = cy1; y <= cy2; y++) {
+        const cellIndex = this.xCellCount * y + x;
+        if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) {
+          return;
         }
       }
     }
-  }, {
-    key: "convertToXCellCoord",
-    value: function convertToXCellCoord(x) {
-      return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
-    }
-  }, {
-    key: "convertToYCellCoord",
-    value: function convertToYCellCoord(y) {
-      return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
-    }
-  }]);
-  return GridIndex;
-}();
+  }
+  convertToXCellCoord(x) {
+    return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
+  }
+  convertToYCellCoord(y) {
+    return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
+  }
+}
 var _default = exports.default = GridIndex;

package/lib/utils/identityScale.d.ts

@@ -0,0 +1,8 @@
+export default function identity(d: any): {
+    (x: any): any;
+    invert: any;
+    domain: (v?: any) => any;
+    range(v?: any): any;
+    unknown(v: any): any;
+    copy(): any;
+};

package/lib/utils/identityScale.js

@@ -5,27 +5,27 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = identity;
 function identity(d) {
-  var unknown;
-  var domain = [];
+  let unknown;
+  let domain = [];
   function scale(x) {
     return x == null ? unknown : x;
   }
   scale.invert = scale;
-  scale.domain = scale.range = function (v) {
+  scale.domain = scale.range = v => {
     if (v) {
       domain = v;
       return v;
     }
     return domain;
   };
-  scale.unknown = function (v) {
+  scale.unknown = v => {
     if (v) {
       unknown = v;
       return v;
     }
     return unknown;
   };
-  scale.copy = function () {
+  scale.copy = () => {
     return identity(d).unknown(unknown);
   };
   return scale;

package/lib/utils/load-image.d.ts

@@ -0,0 +1 @@
+export declare function loadImage(url: string): Promise<HTMLImageElement | ImageBitmap>;

package/lib/utils/load-image.js

@@ -5,49 +5,25 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.loadImage = loadImage;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 function loadImage(_x) {
   return _loadImage.apply(this, arguments);
 }
 function _loadImage() {
-  _loadImage = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(url) {
-    var response, imageBitmap, image;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          if (!window.createImageBitmap) {
-            _context.next = 14;
-            break;
-          }
-          _context.next = 3;
-          return fetch(url);
-        case 3:
-          response = _context.sent;
-          _context.t0 = createImageBitmap;
-          _context.next = 7;
-          return response.blob();
-        case 7:
-          _context.t1 = _context.sent;
-          _context.next = 10;
-          return (0, _context.t0)(_context.t1);
-        case 10:
-          imageBitmap = _context.sent;
-          return _context.abrupt("return", imageBitmap);
-        case 14:
-          image = new window.Image();
-          return _context.abrupt("return", new Promise(function (res) {
-            image.onload = function () {
-              return res(image);
-            };
-            image.src = url;
-            image.crossOrigin = 'Anonymous';
-          }));
-        case 16:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
+  _loadImage = (0, _asyncToGenerator2.default)(function* (url) {
+    // @ts-ignore
+    if (window.createImageBitmap) {
+      const response = yield fetch(url);
+      const imageBitmap = yield createImageBitmap(yield response.blob());
+      return imageBitmap;
+    } else {
+      const image = new window.Image();
+      return new Promise(res => {
+        image.onload = () => res(image);
+        image.src = url;
+        image.crossOrigin = 'Anonymous';
+      });
+    }
+  });
   return _loadImage.apply(this, arguments);
 }

package/lib/utils/multiPassRender.d.ts

@@ -0,0 +1,16 @@
+import type { ILayer, IPass, IPostProcessingPass } from '@antv/l7-core';
+/**
+ * 'blurH' -> ['blurH', {}]
+ */
+export declare function normalizePasses(passes: Array<string | [string, {
+    [key: string]: unknown;
+}]>): [string, {
+    [key: string]: unknown;
+}][];
+/**
+ * 默认添加 ClearPass、RenderPass
+ * 以及 PostProcessing 中的最后一个 CopyPass
+ */
+export declare function createMultiPassRenderer(layer: ILayer, passes: Array<string | [string, {
+    [key: string]: unknown;
+}]>, postProcessingPassFactory: (name: string) => IPostProcessingPass<unknown>, normalPassFactory: (name: string) => IPass<unknown>): import("@antv/l7-core").IMultiPassRenderer;

package/lib/utils/multiPassRender.js

@@ -1,17 +1,15 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMultiPassRenderer = createMultiPassRenderer;
 exports.normalizePasses = normalizePasses;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 /**
  * 'blurH' -> ['blurH', {}]
  */
 function normalizePasses(passes) {
-  return passes.map(function (pass) {
+  return passes.map(pass => {
     if (typeof pass === 'string') {
       pass = [pass, {}];
     }
@@ -24,9 +22,10 @@ function normalizePasses(passes) {
  * 以及 PostProcessing 中的最后一个 CopyPass
  */
 function createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory) {
-  var multiPassRenderer = layer.multiPassRenderer;
-  var _layer$getLayerConfig = layer.getLayerConfig(),
-    enableTAA = _layer$getLayerConfig.enableTAA;
+  const multiPassRenderer = layer.multiPassRenderer;
+  const {
+    enableTAA
+  } = layer.getLayerConfig();
 
   // picking pass if enabled
   // if (enablePicking) {
@@ -42,10 +41,8 @@ function createMultiPassRenderer(layer, passes, postProcessingPassFactory, norma
   }
 
   // post processing
-  normalizePasses(passes).forEach(function (pass) {
-    var _pass = (0, _slicedToArray2.default)(pass, 2),
-      passName = _pass[0],
-      initializationOptions = _pass[1];
+  normalizePasses(passes).forEach(pass => {
+    const [passName, initializationOptions] = pass;
     multiPassRenderer.add(postProcessingPassFactory(passName), initializationOptions);
   });
 

package/lib/utils/polylineNormal.d.ts

@@ -0,0 +1,9 @@
+import { vec2 } from 'gl-matrix';
+export declare function computeMiter(tangent: vec2, miter: vec2, lineA: vec2, lineB: vec2, halfThick: number): number;
+export declare function computeNormal(out: vec2, dir: vec2): vec2;
+export declare function direction(out: vec2, a: [number, number], b: [number, number]): vec2;
+export default function (points: number[][], closed: boolean, indexOffset: number, isDash?: boolean): {
+    normals: number[];
+    attrIndex: number[];
+    attrPos: number[];
+};

package/lib/utils/polylineNormal.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -8,14 +7,13 @@ exports.computeMiter = computeMiter;
 exports.computeNormal = computeNormal;
 exports.default = _default;
 exports.direction = direction;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _l7Utils = require("@antv/l7-utils");
 var _glMatrix = require("gl-matrix");
 function computeMiter(tangent, miter, lineA, lineB, halfThick) {
   _glMatrix.vec2.add(tangent, lineA, lineB);
   _glMatrix.vec2.normalize(tangent, tangent);
   miter = _glMatrix.vec2.fromValues(-tangent[1], tangent[0]);
-  var tmp = _glMatrix.vec2.fromValues(-lineA[1], lineA[0]);
+  const tmp = _glMatrix.vec2.fromValues(-lineA[1], lineA[0]);
   return halfThick / _glMatrix.vec2.dot(miter, tmp);
 }
 function computeNormal(out, dir) {
@@ -39,55 +37,54 @@ function addNext(out, miters, normal, length) {
   miters.push(length);
 }
 function lineSegmentDistance(b1, a1) {
-  var dx = a1[0] - b1[0];
-  var dy = a1[1] - b1[1];
+  const dx = a1[0] - b1[0];
+  const dy = a1[1] - b1[1];
   return Math.sqrt(dx * dx + dy * dy);
 }
 function isPointEqual(a, b) {
   return a[0] === b[0] && a[1] === b[1];
 }
-function _default(points, closed, indexOffset) {
-  var isDash = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
-  var lineA = _glMatrix.vec2.fromValues(0, 0);
-  var lineB = _glMatrix.vec2.fromValues(0, 0);
-  var tangent = _glMatrix.vec2.fromValues(0, 0);
-  var miter = _glMatrix.vec2.create();
-  var started = false;
-  var lineNormal = null;
-  var tmp = _glMatrix.vec2.create();
-  var count = indexOffset || 0;
-  var miterLimit = 4;
-  var out = [];
-  var attrPos = [];
-  var attrIndex = [];
-  var miters = [];
-  var attrDistance = [0, 0];
+function _default(points, closed, indexOffset, isDash = true) {
+  const lineA = _glMatrix.vec2.fromValues(0, 0);
+  const lineB = _glMatrix.vec2.fromValues(0, 0);
+  const tangent = _glMatrix.vec2.fromValues(0, 0);
+  const miter = _glMatrix.vec2.create();
+  let started = false;
+  let lineNormal = null;
+  const tmp = _glMatrix.vec2.create();
+  let count = indexOffset || 0;
+  const miterLimit = 4;
+  const out = [];
+  const attrPos = [];
+  const attrIndex = [];
+  const miters = [];
+  const attrDistance = [0, 0];
   if (closed) {
     points = points.slice();
     points.push(points[0]);
   }
-  var total = points.length;
-  for (var i = 1; i < total; i++) {
-    var index = count;
-    var last = _glMatrix.vec2.fromValues(points[i - 1][0], points[i - 1][1]);
-    var cur = _glMatrix.vec2.fromValues(points[i][0], points[i][1]);
-    var next = i < points.length - 1 ? _glMatrix.vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null;
+  const total = points.length;
+  for (let i = 1; i < total; i++) {
+    const index = count;
+    const last = _glMatrix.vec2.fromValues(points[i - 1][0], points[i - 1][1]);
+    const cur = _glMatrix.vec2.fromValues(points[i][0], points[i][1]);
+    let next = i < points.length - 1 ? _glMatrix.vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null;
     // 如果当前点和前一点相同，跳过
     if (isPointEqual(last, cur)) {
       continue;
     }
     if (next) {
-      var nextIndex = i + 1;
+      let nextIndex = i + 1;
       // 找到不相同的下一点
       while (next && isPointEqual(cur, next)) {
         next = nextIndex < points.length - 1 ? _glMatrix.vec2.fromValues(points[++nextIndex][0], points[nextIndex][1]) : null;
       }
     }
-    var d = 0;
-    var flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
-    var flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
+    let d = 0;
+    const flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
+    const flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
     if (isDash) {
-      var lineDistance = lineSegmentDistance(flatCur, flatLast);
+      const lineDistance = lineSegmentDistance(flatCur, flatLast);
       d = lineDistance + attrDistance[attrDistance.length - 1];
     }
     direction(lineA, flatCur, flatLast);
@@ -110,16 +107,16 @@ function _default(points, closed, indexOffset) {
       attrIndex.push(index + 1, index + 2, index + 3);
       count += 2;
     } else {
-      var flatNext = (0, _l7Utils.aProjectFlat)([next[0], next[1]]);
+      const flatNext = (0, _l7Utils.aProjectFlat)([next[0], next[1]]);
       // get unit dir of next line
       direction(lineB, flatNext, flatCur);
 
       // stores tangent & miter
-      var miterLen = computeMiter(tangent, _glMatrix.vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1);
+      let miterLen = computeMiter(tangent, _glMatrix.vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1);
 
       // get orientation
-      var flip = _glMatrix.vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
-      var bevel = Math.abs(miterLen) > miterLimit;
+      const flip = _glMatrix.vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
+      const bevel = Math.abs(miterLen) > miterLimit;
 
       // 处理前后两条线段重合的情况，这种情况不需要使用任何接头（miter/bevel）。
       // 理论上这种情况下 miterLen = Infinity，本应通过 isFinite(miterLen) 判断，
@@ -147,7 +144,7 @@ function _default(points, closed, indexOffset) {
         attrIndex.push(index + 1, index + 2, index + 3);
 
         // now add the bevel triangle
-        attrIndex.push.apply(attrIndex, (0, _toConsumableArray2.default)(flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]));
+        attrIndex.push(...(flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]));
         computeNormal(tmp, lineB);
         _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
 
@@ -177,17 +174,17 @@ function _default(points, closed, indexOffset) {
       }
     }
   }
-  var pickData = [];
-  for (var _i = 0; _i < miters.length; _i++) {
-    var totalDistance = attrDistance[attrDistance.length - 1];
-    pickData.push(attrPos[_i * 3], attrPos[_i * 3 + 1], attrPos[_i * 3 + 2], attrDistance[_i],
+  const pickData = [];
+  for (let i = 0; i < miters.length; i++) {
+    const totalDistance = attrDistance[attrDistance.length - 1];
+    pickData.push(attrPos[i * 3], attrPos[i * 3 + 1], attrPos[i * 3 + 2], attrDistance[i],
     // dash
-    miters[_i], totalDistance // dash
+    miters[i], totalDistance // dash
     );
   }
   return {
     normals: out,
-    attrIndex: attrIndex,
+    attrIndex,
     attrPos: pickData // [x,y,z, distance, miter ,t0tal ]
   };
 }

package/lib/utils/rampcolor_legend.d.ts

@@ -0,0 +1,6 @@
+import type { ILegend, ScaleTypeName } from '@antv/l7-core';
+export declare function rampColor2legend(rampColors: {
+    type: ScaleTypeName;
+    colors: string[];
+    positions: number[];
+}, name: string): ILegend;