@antv/l7-layers 2.9.26-alpha.0 → 2.9.26

package/es/utils/grid-index.js

@@ -0,0 +1,179 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@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) {
+    _classCallCheck(this, GridIndex);
+
+    _defineProperty(this, "boxCells", []);
+
+    var 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++) {
+      boxCells.push([]);
+    }
+
+    this.boxKeys = [];
+    this.bboxes = [];
+    this.width = width;
+    this.height = height;
+    this.xScale = this.xCellCount / width;
+    this.yScale = this.yCellCount / height;
+    this.boxUid = 0;
+  }
+
+  _createClass(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);
+    }
+  }, {
+    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 : [];
+      }
+
+      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;
+      }
+
+      var queryArgs = {
+        hitTest: hitTest,
+        seenUids: {
+          box: {},
+          circle: {}
+        }
+      };
+      this.forEachCell(x1, y1, x2, y2, this.queryCell, result, queryArgs, predicate);
+      return hitTest ? result.length > 0 : 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]
+                });
+              }
+            }
+          }
+        } 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;
+          }
+        }
+      }
+    }
+  }, {
+    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;
+}();
+
+export default GridIndex;

package/es/utils/layerData.d.ts

@@ -0,0 +1,2 @@
+import { IEncodeFeature, IFontService, ILayer, IMapService, ISourceCFG, IStyleAttributeService } from '@antv/l7-core';
+export declare function calculateData(layer: ILayer, fontService: IFontService, mapService: IMapService, styleAttributeService: IStyleAttributeService, data: any, options: ISourceCFG | undefined): IEncodeFeature[];

package/es/utils/layerData.js

@@ -0,0 +1,176 @@
+import { Version } from '@antv/l7-maps';
+import Source from '@antv/l7-source';
+import { isColor, normalize, rgb2arr } from '@antv/l7-utils';
+
+function getArrowPoints(p1, p2) {
+  var dir = [p2[0] - p1[0], p2[1] - p1[1]];
+  var normalizeDir = normalize(dir);
+  var arrowPoint = [p1[0] + normalizeDir[0] * 0.0001, p1[1] + normalizeDir[1] * 0.0001];
+  return arrowPoint;
+}
+
+function adjustData2Amap2Coordinates(mappedData, mapService) {
+  var _this = this;
+
+  // 根据地图的类型判断是否需要对点位数据进行处理, 若是高德2.0则需要对坐标进行相对偏移
+  if (mappedData.length > 0 && mapService.version === Version['GAODE2.x']) {
+    if (typeof mappedData[0].coordinates[0] === 'number') {
+      // 单个的点数据
+      // @ts-ignore
+      mappedData // TODO: 避免经纬度被重复计算导致坐标位置偏移
+      .filter(function (d) {
+        return !d.originCoordinates;
+      }).map(function (d) {
+        d.version = Version['GAODE2.x']; // @ts-ignore
+
+        d.originCoordinates = cloneDeep(d.coordinates); // 为了兼容高德1.x 需要保存一份原始的经纬度坐标数据（许多上层逻辑依赖经纬度数据）
+        // @ts-ignore
+
+        d.coordinates = _this.mapService.lngLatToCoord(d.coordinates);
+      });
+    } else {
+      // 连续的线、面数据
+      // @ts-ignore
+      mappedData // TODO: 避免经纬度被重复计算导致坐标位置偏移
+      .filter(function (d) {
+        return !d.originCoordinates;
+      }).map(function (d) {
+        d.version = Version['GAODE2.x']; // @ts-ignore
+
+        d.originCoordinates = cloneDeep(d.coordinates); // 为了兼容高德1.x 需要保存一份原始的经纬度坐标数据（许多上层逻辑依赖经纬度数据）
+        // @ts-ignore
+
+        d.coordinates = _this.mapService.lngLatToCoords(d.coordinates);
+      });
+    }
+  }
+}
+
+function adjustData2SimpleCoordinates(mappedData, mapService) {
+  if (mappedData.length > 0 && mapService.version === Version.SIMPLE) {
+    mappedData.map(function (d) {
+      if (!d.simpleCoordinate) {
+        d.coordinates = unProjectCoordinates(d.coordinates, mapService);
+        d.simpleCoordinate = true;
+      }
+    });
+  }
+}
+
+function unProjectCoordinates(coordinates, mapService) {
+  if (typeof coordinates[0] === 'number') {
+    return mapService.simpleMapCoord.unproject(coordinates);
+  }
+
+  if (coordinates[0] && coordinates[0][0] instanceof Array) {
+    // @ts-ignore
+    var coords = [];
+    coordinates.map(function (coord) {
+      // @ts-ignore
+      var c1 = [];
+      coord.map(function (co) {
+        c1.push(mapService.simpleMapCoord.unproject(co));
+      }); // @ts-ignore
+
+      coords.push(c1);
+    }); // @ts-ignore
+
+    return coords;
+  } else {
+    // @ts-ignore
+    var _coords = []; // @ts-ignore
+
+    coordinates.map(function (coord) {
+      _coords.push(mapService.simpleMapCoord.unproject(coord));
+    }); // @ts-ignore
+
+    return _coords;
+  }
+}
+
+function applyAttributeMapping(attribute, record, minimumColor) {
+  var _attribute$scale;
+
+  if (!attribute.scale) {
+    return [];
+  }
+
+  var scalers = (attribute === null || attribute === void 0 ? void 0 : (_attribute$scale = attribute.scale) === null || _attribute$scale === void 0 ? void 0 : _attribute$scale.scalers) || [];
+  var params = [];
+  scalers.forEach(function (_ref) {
+    var _attribute$scale2;
+
+    var field = _ref.field;
+
+    if (record.hasOwnProperty(field) || ((_attribute$scale2 = attribute.scale) === null || _attribute$scale2 === void 0 ? void 0 : _attribute$scale2.type) === 'variable') {
+      // TODO:多字段，常量
+      params.push(record[field]);
+    }
+  });
+  var mappingResult = attribute.mapping ? attribute.mapping(params) : [];
+
+  if (attribute.name === 'color' && !isColor(mappingResult[0])) {
+    return [minimumColor];
+  }
+
+  return mappingResult;
+}
+
+function mapping(attributes, data, fontService, mapService, minimumColor, layer) {
+  var _ref2 = layer === null || layer === void 0 ? void 0 : layer.getLayerConfig(),
+      _ref2$arrow = _ref2.arrow,
+      arrow = _ref2$arrow === void 0 ? {
+    enable: false
+  } : _ref2$arrow;
+
+  var mappedData = data.map(function (record) {
+    var encodeRecord = {
+      id: record._id,
+      coordinates: record.coordinates
+    };
+    attributes.filter(function (attribute) {
+      return attribute.scale !== undefined;
+    }).forEach(function (attribute) {
+      var values = applyAttributeMapping(attribute, record, minimumColor);
+      attribute.needRemapping = false; // TODO: 支持每个属性配置 postprocess
+
+      if (attribute.name === 'color') {
+        values = values.map(function (c) {
+          return rgb2arr(c);
+        });
+      } // @ts-ignore
+
+
+      encodeRecord[attribute.name] = Array.isArray(values) && values.length === 1 ? values[0] : values; // 增加对 layer/text/iconfont unicode 映射的解析
+
+      if (attribute.name === 'shape') {
+        encodeRecord.shape = fontService.getIconFontKey(encodeRecord[attribute.name]);
+      }
+    });
+
+    if (encodeRecord.shape === 'line' && arrow.enable) {
+      // 只有在线图层且支持配置箭头的时候进行插入顶点的处理
+      var coords = encodeRecord.coordinates;
+      var arrowPoint = getArrowPoints(coords[0], coords[1]);
+      encodeRecord.coordinates.splice(1, 0, arrowPoint, arrowPoint);
+    }
+
+    return encodeRecord;
+  }); // 调整数据兼容 Amap2.0
+
+  adjustData2Amap2Coordinates(mappedData, mapService); // 调整数据兼容 SimpleCoordinates
+
+  adjustData2SimpleCoordinates(mappedData, mapService);
+  return mappedData;
+}
+
+export function calculateData(layer, fontService, mapService, styleAttributeService, data, options) {
+  var source = new Source(data, options);
+  var bottomColor = layer.getBottomColor();
+  var attributes = styleAttributeService.getLayerStyleAttributes() || [];
+  var dataArray = source.data.dataArray;
+  var filterData = dataArray;
+  var mappedEncodeData = mapping(attributes, filterData, fontService, mapService, bottomColor, layer);
+  source.destroy();
+  return mappedEncodeData;
+}

package/es/utils/multiPassRender.d.ts

@@ -0,0 +1,16 @@
+import { 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/es/utils/multiPassRender.js

@@ -0,0 +1,50 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+
+/**
+ * 'blurH' -> ['blurH', {}]
+ */
+export function normalizePasses(passes) {
+  return passes.map(function (pass) {
+    if (typeof pass === 'string') {
+      pass = [pass, {}];
+    }
+
+    return pass;
+  });
+}
+/**
+ * 默认添加 ClearPass、RenderPass
+ * 以及 PostProcessing 中的最后一个 CopyPass
+ */
+
+export function createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory) {
+  var multiPassRenderer = layer.multiPassRenderer;
+
+  var _layer$getLayerConfig = layer.getLayerConfig(),
+      enablePicking = _layer$getLayerConfig.enablePicking,
+      enableTAA = _layer$getLayerConfig.enableTAA; // picking pass if enabled
+  // if (enablePicking) {
+  //   multiPassRenderer.add(normalPassFactory('pixelPicking'));
+  // }
+  // use TAA pass if enabled instead of render pass
+
+
+  if (enableTAA) {
+    multiPassRenderer.add(normalPassFactory('taa'));
+  } else {
+    // render all layers in this pass
+    multiPassRenderer.add(normalPassFactory('render'));
+  } // post processing
+
+
+  normalizePasses(passes).forEach(function (pass) {
+    var _pass = _slicedToArray(pass, 2),
+        passName = _pass[0],
+        initializationOptions = _pass[1];
+
+    multiPassRenderer.add(postProcessingPassFactory(passName), initializationOptions);
+  }); // 末尾为固定的 CopyPass
+
+  multiPassRenderer.add(postProcessingPassFactory('copy'));
+  return multiPassRenderer;
+}

package/es/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/es/utils/polylineNormal.js

@@ -0,0 +1,191 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { aProjectFlat } from '@antv/l7-utils';
+import { vec2 } from 'gl-matrix';
+export function computeMiter(tangent, miter, lineA, lineB, halfThick) {
+  vec2.add(tangent, lineA, lineB);
+  vec2.normalize(tangent, tangent);
+  miter = vec2.fromValues(-tangent[1], tangent[0]);
+  var tmp = vec2.fromValues(-lineA[1], lineA[0]);
+  return halfThick / vec2.dot(miter, tmp);
+}
+export function computeNormal(out, dir) {
+  return vec2.set(out, -dir[1], dir[0]);
+}
+export function direction(out, a, b) {
+  // const a1 = aProjectFlat([a[0], a[1]]) as [number, number];
+  // const b1 = aProjectFlat([b[0], b[1]]) as [number, number];
+  vec2.sub(out, a, b);
+  vec2.normalize(out, out);
+  return out;
+}
+
+function extrusions(positions, out, miters, point, normal, scale) {
+  addNext(out, miters, normal, -scale);
+  addNext(out, miters, normal, scale);
+  positions.push(point[0], point[1], 0);
+  positions.push(point[0], point[1], 0);
+}
+
+function addNext(out, miters, normal, length) {
+  out.push(normal[0], normal[1], 0);
+  miters.push(length);
+}
+
+function lineSegmentDistance(b1, a1) {
+  var dx = a1[0] - b1[0];
+  var 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];
+}
+
+export default function (points, closed, indexOffset) {
+  var isDash = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var lineA = vec2.fromValues(0, 0);
+  var lineB = vec2.fromValues(0, 0);
+  var tangent = vec2.fromValues(0, 0);
+  var miter = vec2.create();
+  var started = false;
+  var lineNormal = null;
+  var tmp = vec2.create();
+  var count = indexOffset || 0;
+  var miterLimit = 4;
+  var out = [];
+  var attrPos = [];
+  var attrIndex = [];
+  var miters = [];
+  var 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 = vec2.fromValues(points[i - 1][0], points[i - 1][1]);
+    var cur = vec2.fromValues(points[i][0], points[i][1]);
+    var next = i < points.length - 1 ? vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null; // 如果当前点和前一点相同，跳过
+
+    if (isPointEqual(last, cur)) {
+      continue;
+    }
+
+    if (next) {
+      var nextIndex = i + 1; // 找到不相同的下一点
+
+      while (next && isPointEqual(cur, next)) {
+        next = nextIndex < points.length - 1 ? vec2.fromValues(points[++nextIndex][0], points[nextIndex][1]) : null;
+      }
+    }
+
+    var d = 0;
+    var flatCur = aProjectFlat([cur[0], cur[1]]);
+    var flatLast = aProjectFlat([last[0], last[1]]);
+
+    if (isDash) {
+      var lineDistance = lineSegmentDistance(flatCur, flatLast);
+      d = lineDistance + attrDistance[attrDistance.length - 1];
+    }
+
+    direction(lineA, flatCur, flatLast);
+
+    if (!lineNormal) {
+      lineNormal = vec2.create();
+      computeNormal(lineNormal, lineA);
+    }
+
+    if (!started) {
+      started = true;
+      extrusions(attrPos, out, miters, last, lineNormal, 1);
+    }
+
+    attrIndex.push(index + 0, index + 2, index + 1); // no miter, simple segment
+
+    if (!next) {
+      // reset normal
+      computeNormal(lineNormal, lineA);
+      extrusions(attrPos, out, miters, cur, lineNormal, 1);
+      attrDistance.push(d, d);
+      attrIndex.push(index + 1, index + 2, index + 3);
+      count += 2;
+    } else {
+      var flatNext = aProjectFlat([next[0], next[1]]); // get unit dir of next line
+
+      direction(lineB, flatNext, flatCur); // stores tangent & miter
+
+      var miterLen = computeMiter(tangent, vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1); // get orientation
+
+      var flip = vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
+      var bevel = Math.abs(miterLen) > miterLimit; // 处理前后两条线段重合的情况，这种情况不需要使用任何接头（miter/bevel）。
+      // 理论上这种情况下 miterLen = Infinity，本应通过 isFinite(miterLen) 判断，
+      // 但是 AMap 投影变换后丢失精度，只能通过一个阈值（1000）判断。
+
+      if (Math.abs(miterLen) > 1000) {
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrIndex.push(index + 1, index + 2, index + 3);
+        attrIndex.push(index + 2, index + 4, index + 3);
+        computeNormal(tmp, lineB);
+        vec2.copy(lineNormal, tmp); // store normal for next round
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrDistance.push(d, d, d, d); // the miter is now the normal for our next join
+
+        count += 4;
+        continue;
+      }
+
+      if (bevel) {
+        miterLen = miterLimit; // next two points in our first segment
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrIndex.push(index + 1, index + 2, index + 3); // now add the bevel triangle
+
+        attrIndex.push.apply(attrIndex, _toConsumableArray(flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]));
+        computeNormal(tmp, lineB);
+        vec2.copy(lineNormal, tmp); // store normal for next round
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrDistance.push(d, d, d, d); // the miter is now the normal for our next join
+
+        count += 4;
+      } else {
+        // next two points in our first segment
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrIndex.push(index + 1, index + 2, index + 3); // now add the miter triangles
+
+        addNext(out, miters, lineNormal, miterLen * -flip);
+        attrPos.push(cur[0], cur[1], 0);
+        attrIndex.push(index + 2, index + 4, index + 3);
+        attrIndex.push(index + 4, index + 5, index + 6);
+        computeNormal(tmp, lineB);
+        vec2.copy(lineNormal, tmp); // store normal for next round
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrDistance.push(d, d, d, d, d); // the miter is now the normal for our next join
+
+        count += 5;
+      }
+    }
+  }
+
+  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], // dash
+    miters[_i], totalDistance // dash
+    );
+  }
+
+  return {
+    normals: out,
+    attrIndex: attrIndex,
+    attrPos: pickData // [x,y,z, distance, miter ,t0tal ]
+
+  };
+} // [x,y,z, distance, miter ]

package/es/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;
+}