@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/line/helper.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const dataStackHelper = require("../../data/helper/dataStackHelper.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function prepareDataCoordInfo(coordSys, data, valueOrigin) {
+  var baseAxis = coordSys.getBaseAxis();
+  var valueAxis = coordSys.getOtherAxis(baseAxis);
+  var valueStart = getValueStart(valueAxis, valueOrigin);
+  var baseAxisDim = baseAxis.dim;
+  var valueAxisDim = valueAxis.dim;
+  var valueDim = data.mapDimension(valueAxisDim);
+  var baseDim = data.mapDimension(baseAxisDim);
+  var baseDataOffset = valueAxisDim === "x" || valueAxisDim === "radius" ? 1 : 0;
+  var dims = util.map(coordSys.dimensions, function(coordDim) {
+    return data.mapDimension(coordDim);
+  });
+  var stacked = false;
+  var stackResultDim = data.getCalculationInfo("stackResultDimension");
+  if (dataStackHelper.isDimensionStacked(
+    data,
+    dims[0]
+    /* , dims[1] */
+  )) {
+    stacked = true;
+    dims[0] = stackResultDim;
+  }
+  if (dataStackHelper.isDimensionStacked(
+    data,
+    dims[1]
+    /* , dims[0] */
+  )) {
+    stacked = true;
+    dims[1] = stackResultDim;
+  }
+  return {
+    dataDimsForPoint: dims,
+    valueStart,
+    valueAxisDim,
+    baseAxisDim,
+    stacked: !!stacked,
+    valueDim,
+    baseDim,
+    baseDataOffset,
+    stackedOverDimension: data.getCalculationInfo("stackedOverDimension")
+  };
+}
+function getValueStart(valueAxis, valueOrigin) {
+  var valueStart = 0;
+  var extent = valueAxis.scale.getExtent();
+  if (valueOrigin === "start") {
+    valueStart = extent[0];
+  } else if (valueOrigin === "end") {
+    valueStart = extent[1];
+  } else if (util.isNumber(valueOrigin) && !isNaN(valueOrigin)) {
+    valueStart = valueOrigin;
+  } else {
+    if (extent[0] > 0) {
+      valueStart = extent[0];
+    } else if (extent[1] < 0) {
+      valueStart = extent[1];
+    }
+  }
+  return valueStart;
+}
+function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) {
+  var value = NaN;
+  if (dataCoordInfo.stacked) {
+    value = data.get(data.getCalculationInfo("stackedOverDimension"), idx);
+  }
+  if (isNaN(value)) {
+    value = dataCoordInfo.valueStart;
+  }
+  var baseDataOffset = dataCoordInfo.baseDataOffset;
+  var stackedData = [];
+  stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx);
+  stackedData[1 - baseDataOffset] = value;
+  return coordSys.dataToPoint(stackedData);
+}
+exports.getStackedOnPoint = getStackedOnPoint;
+exports.prepareDataCoordInfo = prepareDataCoordInfo;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/line/install.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const LineSeries = require("./LineSeries.js");
+const LineView = require("./LineView.js");
+const points = require("../../layout/points.js");
+const dataSample = require("../../processor/dataSample.js");
+function install(registers) {
+  registers.registerChartView(LineView.default);
+  registers.registerSeriesModel(LineSeries.default);
+  registers.registerLayout(points.default("line"));
+  registers.registerVisual({
+    seriesType: "line",
+    reset: function(seriesModel) {
+      var data = seriesModel.getData();
+      var lineStyle = seriesModel.getModel("lineStyle").getLineStyle();
+      if (lineStyle && !lineStyle.stroke) {
+        lineStyle.stroke = data.getVisual("style").fill;
+      }
+      data.setVisual("legendLineStyle", lineStyle);
+    }
+  });
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, dataSample.default("line"));
+}
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/line/lineAnimationDiff.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const helper = require("./helper.js");
+const vendor = require("../../util/vendor.js");
+function diffData(oldData, newData) {
+  var diffResult = [];
+  newData.diff(oldData).add(function(idx) {
+    diffResult.push({
+      cmd: "+",
+      idx
+    });
+  }).update(function(newIdx, oldIdx) {
+    diffResult.push({
+      cmd: "=",
+      idx: oldIdx,
+      idx1: newIdx
+    });
+  }).remove(function(idx) {
+    diffResult.push({
+      cmd: "-",
+      idx
+    });
+  }).execute();
+  return diffResult;
+}
+function lineAnimationDiff(oldData, newData, oldStackedOnPoints, newStackedOnPoints, oldCoordSys, newCoordSys, oldValueOrigin, newValueOrigin) {
+  var diff = diffData(oldData, newData);
+  var currPoints = [];
+  var nextPoints = [];
+  var currStackedPoints = [];
+  var nextStackedPoints = [];
+  var status = [];
+  var sortedIndices = [];
+  var rawIndices = [];
+  var newDataOldCoordInfo = helper.prepareDataCoordInfo(oldCoordSys, newData, oldValueOrigin);
+  var oldPoints = oldData.getLayout("points") || [];
+  var newPoints = newData.getLayout("points") || [];
+  for (var i = 0; i < diff.length; i++) {
+    var diffItem = diff[i];
+    var pointAdded = true;
+    var oldIdx2 = void 0;
+    var newIdx2 = void 0;
+    switch (diffItem.cmd) {
+      case "=":
+        oldIdx2 = diffItem.idx * 2;
+        newIdx2 = diffItem.idx1 * 2;
+        var currentX = oldPoints[oldIdx2];
+        var currentY = oldPoints[oldIdx2 + 1];
+        var nextX = newPoints[newIdx2];
+        var nextY = newPoints[newIdx2 + 1];
+        if (isNaN(currentX) || isNaN(currentY)) {
+          currentX = nextX;
+          currentY = nextY;
+        }
+        currPoints.push(currentX, currentY);
+        nextPoints.push(nextX, nextY);
+        currStackedPoints.push(oldStackedOnPoints[oldIdx2], oldStackedOnPoints[oldIdx2 + 1]);
+        nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]);
+        rawIndices.push(newData.getRawIndex(diffItem.idx1));
+        break;
+      case "+":
+        var newIdx = diffItem.idx;
+        var newDataDimsForPoint = newDataOldCoordInfo.dataDimsForPoint;
+        var oldPt = oldCoordSys.dataToPoint([newData.get(newDataDimsForPoint[0], newIdx), newData.get(newDataDimsForPoint[1], newIdx)]);
+        newIdx2 = newIdx * 2;
+        currPoints.push(oldPt[0], oldPt[1]);
+        nextPoints.push(newPoints[newIdx2], newPoints[newIdx2 + 1]);
+        var stackedOnPoint = helper.getStackedOnPoint(newDataOldCoordInfo, oldCoordSys, newData, newIdx);
+        currStackedPoints.push(stackedOnPoint[0], stackedOnPoint[1]);
+        nextStackedPoints.push(newStackedOnPoints[newIdx2], newStackedOnPoints[newIdx2 + 1]);
+        rawIndices.push(newData.getRawIndex(newIdx));
+        break;
+      case "-":
+        pointAdded = false;
+    }
+    if (pointAdded) {
+      status.push(diffItem);
+      sortedIndices.push(sortedIndices.length);
+    }
+  }
+  sortedIndices.sort(function(a, b) {
+    return rawIndices[a] - rawIndices[b];
+  });
+  var len = currPoints.length;
+  var sortedCurrPoints = vendor.createFloat32Array(len);
+  var sortedNextPoints = vendor.createFloat32Array(len);
+  var sortedCurrStackedPoints = vendor.createFloat32Array(len);
+  var sortedNextStackedPoints = vendor.createFloat32Array(len);
+  var sortedStatus = [];
+  for (var i = 0; i < sortedIndices.length; i++) {
+    var idx = sortedIndices[i];
+    var i2 = i * 2;
+    var idx2 = idx * 2;
+    sortedCurrPoints[i2] = currPoints[idx2];
+    sortedCurrPoints[i2 + 1] = currPoints[idx2 + 1];
+    sortedNextPoints[i2] = nextPoints[idx2];
+    sortedNextPoints[i2 + 1] = nextPoints[idx2 + 1];
+    sortedCurrStackedPoints[i2] = currStackedPoints[idx2];
+    sortedCurrStackedPoints[i2 + 1] = currStackedPoints[idx2 + 1];
+    sortedNextStackedPoints[i2] = nextStackedPoints[idx2];
+    sortedNextStackedPoints[i2 + 1] = nextStackedPoints[idx2 + 1];
+    sortedStatus[i] = status[idx];
+  }
+  return {
+    current: sortedCurrPoints,
+    next: sortedNextPoints,
+    stackedOnCurrent: sortedCurrStackedPoints,
+    stackedOnNext: sortedNextStackedPoints,
+    status: sortedStatus
+  };
+}
+exports.default = lineAnimationDiff;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/line/poly.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Path = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Path.js");
+const PathProxy = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/PathProxy.js");
+const curve = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/curve.js");
+var mathMin = Math.min;
+var mathMax = Math.max;
+function isPointNull(x, y) {
+  return isNaN(x) || isNaN(y);
+}
+function drawSegment(ctx, points, start, segLen, allLen, dir, smooth, smoothMonotone, connectNulls) {
+  var prevX;
+  var prevY;
+  var cpx0;
+  var cpy0;
+  var cpx1;
+  var cpy1;
+  var idx = start;
+  var k = 0;
+  for (; k < segLen; k++) {
+    var x = points[idx * 2];
+    var y = points[idx * 2 + 1];
+    if (idx >= allLen || idx < 0) {
+      break;
+    }
+    if (isPointNull(x, y)) {
+      if (connectNulls) {
+        idx += dir;
+        continue;
+      }
+      break;
+    }
+    if (idx === start) {
+      ctx[dir > 0 ? "moveTo" : "lineTo"](x, y);
+      cpx0 = x;
+      cpy0 = y;
+    } else {
+      var dx = x - prevX;
+      var dy = y - prevY;
+      if (dx * dx + dy * dy < 0.5) {
+        idx += dir;
+        continue;
+      }
+      if (smooth > 0) {
+        var nextIdx = idx + dir;
+        var nextX = points[nextIdx * 2];
+        var nextY = points[nextIdx * 2 + 1];
+        while (nextX === x && nextY === y && k < segLen) {
+          k++;
+          nextIdx += dir;
+          idx += dir;
+          nextX = points[nextIdx * 2];
+          nextY = points[nextIdx * 2 + 1];
+          x = points[idx * 2];
+          y = points[idx * 2 + 1];
+          dx = x - prevX;
+          dy = y - prevY;
+        }
+        var tmpK = k + 1;
+        if (connectNulls) {
+          while (isPointNull(nextX, nextY) && tmpK < segLen) {
+            tmpK++;
+            nextIdx += dir;
+            nextX = points[nextIdx * 2];
+            nextY = points[nextIdx * 2 + 1];
+          }
+        }
+        var ratioNextSeg = 0.5;
+        var vx = 0;
+        var vy = 0;
+        var nextCpx0 = void 0;
+        var nextCpy0 = void 0;
+        if (tmpK >= segLen || isPointNull(nextX, nextY)) {
+          cpx1 = x;
+          cpy1 = y;
+        } else {
+          vx = nextX - prevX;
+          vy = nextY - prevY;
+          var dx0 = x - prevX;
+          var dx1 = nextX - x;
+          var dy0 = y - prevY;
+          var dy1 = nextY - y;
+          var lenPrevSeg = void 0;
+          var lenNextSeg = void 0;
+          if (smoothMonotone === "x") {
+            lenPrevSeg = Math.abs(dx0);
+            lenNextSeg = Math.abs(dx1);
+            var dir_1 = vx > 0 ? 1 : -1;
+            cpx1 = x - dir_1 * lenPrevSeg * smooth;
+            cpy1 = y;
+            nextCpx0 = x + dir_1 * lenNextSeg * smooth;
+            nextCpy0 = y;
+          } else if (smoothMonotone === "y") {
+            lenPrevSeg = Math.abs(dy0);
+            lenNextSeg = Math.abs(dy1);
+            var dir_2 = vy > 0 ? 1 : -1;
+            cpx1 = x;
+            cpy1 = y - dir_2 * lenPrevSeg * smooth;
+            nextCpx0 = x;
+            nextCpy0 = y + dir_2 * lenNextSeg * smooth;
+          } else {
+            lenPrevSeg = Math.sqrt(dx0 * dx0 + dy0 * dy0);
+            lenNextSeg = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+            ratioNextSeg = lenNextSeg / (lenNextSeg + lenPrevSeg);
+            cpx1 = x - vx * smooth * (1 - ratioNextSeg);
+            cpy1 = y - vy * smooth * (1 - ratioNextSeg);
+            nextCpx0 = x + vx * smooth * ratioNextSeg;
+            nextCpy0 = y + vy * smooth * ratioNextSeg;
+            nextCpx0 = mathMin(nextCpx0, mathMax(nextX, x));
+            nextCpy0 = mathMin(nextCpy0, mathMax(nextY, y));
+            nextCpx0 = mathMax(nextCpx0, mathMin(nextX, x));
+            nextCpy0 = mathMax(nextCpy0, mathMin(nextY, y));
+            vx = nextCpx0 - x;
+            vy = nextCpy0 - y;
+            cpx1 = x - vx * lenPrevSeg / lenNextSeg;
+            cpy1 = y - vy * lenPrevSeg / lenNextSeg;
+            cpx1 = mathMin(cpx1, mathMax(prevX, x));
+            cpy1 = mathMin(cpy1, mathMax(prevY, y));
+            cpx1 = mathMax(cpx1, mathMin(prevX, x));
+            cpy1 = mathMax(cpy1, mathMin(prevY, y));
+            vx = x - cpx1;
+            vy = y - cpy1;
+            nextCpx0 = x + vx * lenNextSeg / lenPrevSeg;
+            nextCpy0 = y + vy * lenNextSeg / lenPrevSeg;
+          }
+        }
+        ctx.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y);
+        cpx0 = nextCpx0;
+        cpy0 = nextCpy0;
+      } else {
+        ctx.lineTo(x, y);
+      }
+    }
+    prevX = x;
+    prevY = y;
+    idx += dir;
+  }
+  return k;
+}
+var ECPolylineShape = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function ECPolylineShape2() {
+      this.smooth = 0;
+      this.smoothConstraint = true;
+    }
+    return ECPolylineShape2;
+  }()
+);
+var ECPolyline = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(ECPolyline2, _super);
+    function ECPolyline2(opts) {
+      var _this = _super.call(this, opts) || this;
+      _this.type = "ec-polyline";
+      return _this;
+    }
+    ECPolyline2.prototype.getDefaultStyle = function() {
+      return {
+        stroke: "#000",
+        fill: null
+      };
+    };
+    ECPolyline2.prototype.getDefaultShape = function() {
+      return new ECPolylineShape();
+    };
+    ECPolyline2.prototype.buildPath = function(ctx, shape) {
+      var points = shape.points;
+      var i = 0;
+      var len = points.length / 2;
+      if (shape.connectNulls) {
+        for (; len > 0; len--) {
+          if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
+            break;
+          }
+        }
+        for (; i < len; i++) {
+          if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
+            break;
+          }
+        }
+      }
+      while (i < len) {
+        i += drawSegment(ctx, points, i, len, len, 1, shape.smooth, shape.smoothMonotone, shape.connectNulls) + 1;
+      }
+    };
+    ECPolyline2.prototype.getPointOn = function(xOrY, dim) {
+      if (!this.path) {
+        this.createPathProxy();
+        this.buildPath(this.path, this.shape);
+      }
+      var path = this.path;
+      var data = path.data;
+      var CMD = PathProxy.default.CMD;
+      var x0;
+      var y0;
+      var isDimX = dim === "x";
+      var roots = [];
+      for (var i = 0; i < data.length; ) {
+        var cmd = data[i++];
+        var x = void 0;
+        var y = void 0;
+        var x2 = void 0;
+        var y2 = void 0;
+        var x3 = void 0;
+        var y3 = void 0;
+        var t = void 0;
+        switch (cmd) {
+          case CMD.M:
+            x0 = data[i++];
+            y0 = data[i++];
+            break;
+          case CMD.L:
+            x = data[i++];
+            y = data[i++];
+            t = isDimX ? (xOrY - x0) / (x - x0) : (xOrY - y0) / (y - y0);
+            if (t <= 1 && t >= 0) {
+              var val = isDimX ? (y - y0) * t + y0 : (x - x0) * t + x0;
+              return isDimX ? [xOrY, val] : [val, xOrY];
+            }
+            x0 = x;
+            y0 = y;
+            break;
+          case CMD.C:
+            x = data[i++];
+            y = data[i++];
+            x2 = data[i++];
+            y2 = data[i++];
+            x3 = data[i++];
+            y3 = data[i++];
+            var nRoot = isDimX ? curve.cubicRootAt(x0, x, x2, x3, xOrY, roots) : curve.cubicRootAt(y0, y, y2, y3, xOrY, roots);
+            if (nRoot > 0) {
+              for (var i_1 = 0; i_1 < nRoot; i_1++) {
+                var t_1 = roots[i_1];
+                if (t_1 <= 1 && t_1 >= 0) {
+                  var val = isDimX ? curve.cubicAt(y0, y, y2, y3, t_1) : curve.cubicAt(x0, x, x2, x3, t_1);
+                  return isDimX ? [xOrY, val] : [val, xOrY];
+                }
+              }
+            }
+            x0 = x3;
+            y0 = y3;
+            break;
+        }
+      }
+    };
+    return ECPolyline2;
+  }(Path.default)
+);
+var ECPolygonShape = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(ECPolygonShape2, _super);
+    function ECPolygonShape2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return ECPolygonShape2;
+  }(ECPolylineShape)
+);
+var ECPolygon = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(ECPolygon2, _super);
+    function ECPolygon2(opts) {
+      var _this = _super.call(this, opts) || this;
+      _this.type = "ec-polygon";
+      return _this;
+    }
+    ECPolygon2.prototype.getDefaultShape = function() {
+      return new ECPolygonShape();
+    };
+    ECPolygon2.prototype.buildPath = function(ctx, shape) {
+      var points = shape.points;
+      var stackedOnPoints = shape.stackedOnPoints;
+      var i = 0;
+      var len = points.length / 2;
+      var smoothMonotone = shape.smoothMonotone;
+      if (shape.connectNulls) {
+        for (; len > 0; len--) {
+          if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
+            break;
+          }
+        }
+        for (; i < len; i++) {
+          if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
+            break;
+          }
+        }
+      }
+      while (i < len) {
+        var k = drawSegment(ctx, points, i, len, len, 1, shape.smooth, smoothMonotone, shape.connectNulls);
+        drawSegment(ctx, stackedOnPoints, i + k - 1, k, len, -1, shape.stackedOnSmooth, smoothMonotone, shape.connectNulls);
+        i += k + 1;
+        ctx.closePath();
+      }
+    };
+    return ECPolygon2;
+  }(Path.default)
+);
+exports.ECPolygon = ECPolygon;
+exports.ECPolyline = ECPolyline;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/pie/PieSeries.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const createSeriesDataSimply = require("../helper/createSeriesDataSimply.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const model = require("../../util/model.js");
+const number = require("../../util/number.js");
+const sourceHelper = require("../../data/helper/sourceHelper.js");
+const LegendVisualProvider = require("../../visual/LegendVisualProvider.js");
+const Series = require("../../model/Series.js");
+var innerData = model.makeInner();
+var PieSeriesModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(PieSeriesModel2, _super);
+    function PieSeriesModel2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PieSeriesModel2.prototype.init = function(option) {
+      _super.prototype.init.apply(this, arguments);
+      this.legendVisualProvider = new LegendVisualProvider.default(util.bind(this.getData, this), util.bind(this.getRawData, this));
+      this._defaultLabelLine(option);
+    };
+    PieSeriesModel2.prototype.mergeOption = function() {
+      _super.prototype.mergeOption.apply(this, arguments);
+    };
+    PieSeriesModel2.prototype.getInitialData = function() {
+      return createSeriesDataSimply.default(this, {
+        coordDimensions: ["value"],
+        encodeDefaulter: util.curry(sourceHelper.makeSeriesEncodeForNameBased, this)
+      });
+    };
+    PieSeriesModel2.prototype.getDataParams = function(dataIndex) {
+      var data = this.getData();
+      var dataInner = innerData(data);
+      var seats = dataInner.seats;
+      if (!seats) {
+        var valueList_1 = [];
+        data.each(data.mapDimension("value"), function(value) {
+          valueList_1.push(value);
+        });
+        seats = dataInner.seats = number.getPercentSeats(valueList_1, data.hostModel.get("percentPrecision"));
+      }
+      var params = _super.prototype.getDataParams.call(this, dataIndex);
+      params.percent = seats[dataIndex] || 0;
+      params.$vars.push("percent");
+      return params;
+    };
+    PieSeriesModel2.prototype._defaultLabelLine = function(option) {
+      model.defaultEmphasis(option, "labelLine", ["show"]);
+      var labelLineNormalOpt = option.labelLine;
+      var labelLineEmphasisOpt = option.emphasis.labelLine;
+      labelLineNormalOpt.show = labelLineNormalOpt.show && option.label.show;
+      labelLineEmphasisOpt.show = labelLineEmphasisOpt.show && option.emphasis.label.show;
+    };
+    PieSeriesModel2.type = "series.pie";
+    PieSeriesModel2.defaultOption = {
+      // zlevel: 0,
+      z: 2,
+      legendHoverLink: true,
+      colorBy: "data",
+      // 默认全局居中
+      center: ["50%", "50%"],
+      radius: [0, "75%"],
+      // 默认顺时针
+      clockwise: true,
+      startAngle: 90,
+      endAngle: "auto",
+      padAngle: 0,
+      // 最小角度改为0
+      minAngle: 0,
+      // If the angle of a sector less than `minShowLabelAngle`,
+      // the label will not be displayed.
+      minShowLabelAngle: 0,
+      // 选中时扇区偏移量
+      selectedOffset: 10,
+      // 选择模式，默认关闭，可选single，multiple
+      // selectedMode: false,
+      // 南丁格尔玫瑰图模式，'radius'（半径） | 'area'（面积）
+      // roseType: null,
+      percentPrecision: 2,
+      // If still show when all data zero.
+      stillShowZeroSum: true,
+      // cursor: null,
+      left: 0,
+      top: 0,
+      right: 0,
+      bottom: 0,
+      width: null,
+      height: null,
+      label: {
+        // color: 'inherit',
+        // If rotate around circle
+        rotate: 0,
+        show: true,
+        overflow: "truncate",
+        // 'outer', 'inside', 'center'
+        position: "outer",
+        // 'none', 'labelLine', 'edge'. Works only when position is 'outer'
+        alignTo: "none",
+        // Closest distance between label and chart edge.
+        // Works only position is 'outer' and alignTo is 'edge'.
+        edgeDistance: "25%",
+        // Works only position is 'outer' and alignTo is not 'edge'.
+        bleedMargin: 10,
+        // Distance between text and label line.
+        distanceToLabelLine: 5
+        // formatter: 标签文本格式器，同 tooltip.formatter，不支持异步回调
+        // 默认使用全局文本样式，详见 textStyle
+        // distance: 当position为inner时有效，为label位置到圆心的距离与圆半径(环状图为内外半径和)的比例系数
+      },
+      // Enabled when label.normal.position is 'outer'
+      labelLine: {
+        show: true,
+        // 引导线两段中的第一段长度
+        length: 15,
+        // 引导线两段中的第二段长度
+        length2: 15,
+        smooth: false,
+        minTurnAngle: 90,
+        maxSurfaceAngle: 90,
+        lineStyle: {
+          // color: 各异,
+          width: 1,
+          type: "solid"
+        }
+      },
+      itemStyle: {
+        borderWidth: 1,
+        borderJoin: "round"
+      },
+      showEmptyCircle: true,
+      emptyCircleStyle: {
+        color: "lightgray",
+        opacity: 1
+      },
+      labelLayout: {
+        // Hide the overlapped label.
+        hideOverlap: true
+      },
+      emphasis: {
+        scale: true,
+        scaleSize: 5
+      },
+      // If use strategy to avoid label overlapping
+      avoidLabelOverlap: true,
+      // Animation type. Valid values: expansion, scale
+      animationType: "expansion",
+      animationDuration: 1e3,
+      // Animation type when update. Valid values: transition, expansion
+      animationTypeUpdate: "transition",
+      animationEasingUpdate: "cubicInOut",
+      animationDurationUpdate: 500,
+      animationEasing: "cubicInOut"
+    };
+    return PieSeriesModel2;
+  }(Series.default)
+);
+exports.default = PieSeriesModel;