@visactor/vchart 1.3.0 → 1.3.1-test.1

package/build/index.js

@@ -8245,7 +8245,6 @@
 	  };
 	}
 
-	const isClose = isNumberClose;
 	function normalizeAngle$2(angle) {
 	    while (angle < 0) {
 	        angle += Math.PI * 2;
@@ -8276,79 +8275,6 @@
 	        y: Math.sin(point.angle) * point.radius
 	    };
 	}
-	function circlePoint$1(x0, y0, radius, radian) {
-	    const offset = polarToCartesian$1({
-	        radius,
-	        angle: radian
-	    });
-	    return {
-	        x: x0 + offset.x,
-	        y: y0 + offset.y
-	    };
-	}
-	function lineCirclePoints$1(a, b, c, x0, y0, r) {
-	    if ((a === 0 && b === 0) || r <= 0) {
-	        return [];
-	    }
-	    if (a === 0) {
-	        const y1 = -c / b;
-	        const fy = (y1 - y0) ** 2;
-	        const fd = r ** 2 - fy;
-	        if (fd < 0) {
-	            return [];
-	        }
-	        else if (fd === 0) {
-	            return [{ x: x0, y: y1 }];
-	        }
-	        const x1 = Math.sqrt(fd) + x0;
-	        const x2 = -Math.sqrt(fd) + x0;
-	        return [
-	            { x: x1, y: y1 },
-	            { x: x2, y: y1 }
-	        ];
-	    }
-	    else if (b === 0) {
-	        const x1 = -c / a;
-	        const fx = (x1 - x0) ** 2;
-	        const fd = r ** 2 - fx;
-	        if (fd < 0) {
-	            return [];
-	        }
-	        else if (fd === 0) {
-	            return [{ x: x1, y: y0 }];
-	        }
-	        const y1 = Math.sqrt(fd) + y0;
-	        const y2 = -Math.sqrt(fd) + y0;
-	        return [
-	            { x: x1, y: y1 },
-	            { x: x1, y: y2 }
-	        ];
-	    }
-	    const fa = (b / a) ** 2 + 1;
-	    const fb = 2 * ((c / a + x0) * (b / a) - y0);
-	    const fc = (c / a + x0) ** 2 + y0 ** 2 - r ** 2;
-	    const fd = fb ** 2 - 4 * fa * fc;
-	    if (fd < 0) {
-	        return [];
-	    }
-	    const y1 = (-fb + Math.sqrt(fd)) / (2 * fa);
-	    const y2 = (-fb - Math.sqrt(fd)) / (2 * fa);
-	    const x1 = -(b * y1 + c) / a;
-	    const x2 = -(b * y2 + c) / a;
-	    if (fd === 0) {
-	        return [{ x: x1, y: y1 }];
-	    }
-	    return [
-	        { x: x1, y: y1 },
-	        { x: x2, y: y2 }
-	    ];
-	}
-	function connectLineRadian$1(radius, length) {
-	    if (length > radius * 2) {
-	        return NaN;
-	    }
-	    return Math.asin(length / 2 / radius) * 2;
-	}
 	function computeQuadrant$2(angle) {
 	    angle = normalizeAngle$2(angle);
 	    if (angle > 0 && angle <= Math.PI / 2) {
@@ -8396,20 +8322,6 @@
 	    }
 	    return { startAngle, endAngle };
 	}
-	function isQuadrantLeft$1(quadrant) {
-	    return quadrant === 3 || quadrant === 4;
-	}
-	function isQuadrantRight$1(quadrant) {
-	    return quadrant === 1 || quadrant === 2;
-	}
-	function checkBoundsOverlap$1(boundsA, boundsB) {
-	    const { x1: ax1, y1: ay1, x2: ax2, y2: ay2 } = boundsA;
-	    const { x1: bx1, y1: by1, x2: bx2, y2: by2 } = boundsB;
-	    return !((ax1 <= bx1 && ax2 <= bx1) ||
-	        (ax1 >= bx2 && ax2 >= bx2) ||
-	        (ay1 <= by1 && ay2 <= by1) ||
-	        (ay1 >= by2 && ay2 >= by2));
-	}
 	function outOfBounds(bounds, x, y) {
 	    return bounds.x1 > x || bounds.x2 < x || bounds.y1 > y || bounds.y2 < y;
 	}
@@ -40174,7 +40086,7 @@
 	        mergedParameters = Object.assign({
 	          [DefaultAnimationParameters]: animationParameters
 	        }, parameters),
-	        animationUnit = this.getAnimationUnit(config.timeline, element, index, animatedElements.length, parameters);
+	        animationUnit = this.getAnimationUnit(config.timeline, element, index, animatedElements.length, mergedParameters);
 	      animators.push(this.animateElement(config, animationUnit, element, animationParameters, mergedParameters));
 	    })), animators;
 	  }
@@ -40415,7 +40327,7 @@
 	  parameters() {
 	    const params = {};
 	    return this.references.forEach((count, ref) => {
-	      params[ref.id()] = ref.output();
+	      isValid(ref.id()) && (params[ref.id()] = ref.output());
 	    }), params;
 	  }
 	  getSpec() {
@@ -40876,8 +40788,8 @@
 	    return !isNil(this.spec.layout);
 	  }
 	  handleLayoutEnd() {
-	    var _a;
-	    (null === (_a = this.spec.layout) || void 0 === _a ? void 0 : _a.skipBeforeLayouted) && this.run();
+	    var _a, _b;
+	    (null === (_b = null === (_a = this.spec) || void 0 === _a ? void 0 : _a.layout) || void 0 === _b ? void 0 : _b.skipBeforeLayouted) && this.run();
 	  }
 	  handleRenderEnd() {
 	    this.needClear && (this.cleanExitElements(), this.elementMap.forEach(element => {
@@ -43371,7 +43283,7 @@
 	  return !(ax1 <= bx1 && ax2 <= bx1 || ax1 >= bx2 && ax2 >= bx2 || ay1 <= by1 && ay2 <= by1 || ay1 >= by2 && ay2 >= by2);
 	}
 
-	let ArcInfo$1 = class ArcInfo {
+	class ArcInfo {
 	  constructor(refDatum, center, outerCenter, quadrant, radian, middleAngle) {
 	    this.refDatum = refDatum, this.center = center, this.outerCenter = outerCenter, this.quadrant = quadrant, this.radian = radian, this.middleAngle = middleAngle, this.labelVisible = !0, this.labelLimit = 0;
 	  }
@@ -43388,7 +43300,7 @@
 	      y2: 0
 	    };
 	  }
-	};
+	}
 	class ArcLabel extends LabelBase {
 	  constructor(attributes) {
 	    super(merge$2({}, ArcLabel.defaultAttributes, attributes)), this.name = "arc-label", this._ellipsisWidth = 0, this._arcLeft = new Map(), this._arcRight = new Map();
@@ -43449,7 +43361,7 @@
 	        arcQuadrant = computeQuadrant(graphicAttribute.endAngle - intervalAngle / 2),
 	        arcMiddle = circlePoint(center.x, center.y, graphicAttribute.outerRadius, arcMiddleAngle),
 	        outerArcMiddle = circlePoint(center.x, center.y, maxRadius + attribute.line.line1MinLength, arcMiddleAngle),
-	        arc = new ArcInfo$1(item, arcMiddle, outerArcMiddle, arcQuadrant, intervalAngle, arcMiddleAngle);
+	        arc = new ArcInfo(item, arcMiddle, outerArcMiddle, arcQuadrant, intervalAngle, arcMiddleAngle);
 	      arc.pointA = circlePoint(center.x, center.y, this.computeDatumRadius(2 * center.x, 2 * center.y, graphicAttribute.outerRadius, centerOffset), arc.middleAngle), arc.labelSize = {
 	        width: textBounds.x2 - textBounds.x1,
 	        height: textBounds.y2 - textBounds.y1
@@ -50056,7 +49968,7 @@
 	  },
 	  smartInvert: !1
 	};
-	const arcLabel$1 = {
+	const arcLabel = {
 	  type: "arc",
 	  data: [{
 	    text: "",
@@ -50102,7 +50014,7 @@
 	  lineLabel: lineLabel,
 	  rectLabel: rectLabel,
 	  symbolLabel: symbolLabel$1,
-	  arcLabel: arcLabel$1,
+	  arcLabel: arcLabel,
 	  datazoom: datazoom,
 	  continuousPlayer: continuousPlayer,
 	  discretePlayer: discretePlayer,
@@ -53622,11 +53534,11 @@
 	    }
 	  }
 	  addGrammar(grammar) {
-	    return this.grammars.find(storedGrammar => storedGrammar.uid === grammar.uid) || (this.grammars.record(grammar), this._dataflow.add(grammar), grammar.parse(grammar.getSpec())), this;
+	    return this.grammars.find(storedGrammar => storedGrammar.uid === grammar.uid) || (this.grammars.record(grammar), this._dataflow.add(grammar), grammar.parse(grammar.getSpec()), this._needBuildLayoutTree = !0), this;
 	  }
 	  removeGrammar(grammar) {
 	    const recordedGrammar = isString(grammar) ? this.getGrammarById(grammar) : grammar;
-	    return recordedGrammar && this.grammars.find(storedGrammar => storedGrammar.uid === recordedGrammar.uid) ? ("mark" === recordedGrammar.grammarType && recordedGrammar.prepareRelease(), this._cachedGrammars.record(recordedGrammar), this._dataflow.remove(recordedGrammar), this.grammars.unrecord(recordedGrammar), this) : this;
+	    return recordedGrammar && this.grammars.find(storedGrammar => storedGrammar.uid === recordedGrammar.uid) ? ("mark" === recordedGrammar.grammarType && recordedGrammar.prepareRelease(), this._cachedGrammars.record(recordedGrammar), this._dataflow.remove(recordedGrammar), this.grammars.unrecord(recordedGrammar), this._needBuildLayoutTree = !0, this) : this;
 	  }
 	  removeAllGrammars() {
 	    return this.grammars.traverse(grammar => {
@@ -54271,16 +54183,10 @@
 	const ARC_START_ANGLE = `${PREFIX}_ARC_START_ANGLE`;
 	const ARC_END_ANGLE = `${PREFIX}_ARC_END_ANGLE`;
 	const ARC_K = `${PREFIX}_ARC_K`;
-	const ARC_LABEL_HOVER_AX = `${PREFIX}_ARC_LABEL_HOVER_AX`;
-	const ARC_LABEL_HOVER_AY = `${PREFIX}_ARC_LABEL_HOVER_AY`;
-	const ARC_LABEL_POINT_AX = `${PREFIX}_ARC_LABEL_POINT_AX`;
-	const ARC_LABEL_POINT_AY = `${PREFIX}_ARC_LABEL_POINT_AY`;
 	const ARC_LABEL_POINT_BX = `${PREFIX}_ARC_LABEL_POINT_BX`;
 	const ARC_LABEL_POINT_BY = `${PREFIX}_ARC_LABEL_POINT_BY`;
 	const ARC_LABEL_POINT_CX = `${PREFIX}_ARC_LABEL_POINT_CX`;
 	const ARC_LABEL_POINT_CY = `${PREFIX}_ARC_LABEL_POINT_CY`;
-	const ARC_LABEL_SELECTED_AX = `${PREFIX}_ARC_LABEL_SELECTED_AX`;
-	const ARC_LABEL_SELECTED_AY = `${PREFIX}_ARC_LABEL_SELECTED_AY`;
 	const ARC_MIDDLE_ANGLE = `${PREFIX}_ARC_MIDDLE_ANGLE`;
 	const ARC_QUADRANT = `${PREFIX}_ARC_QUADRANT`;
 	const ARC_RADIAN = `${PREFIX}_ARC_RADIAN`;
@@ -56002,6 +55908,10 @@
 	    STATE_LEVEL[STATE_LEVEL["HOVER"] = 6] = "HOVER";
 	})(STATE_LEVEL || (STATE_LEVEL = {}));
 
+	const lineLikeSeriesMark = {
+	    [SeriesMarkNameEnum.point]: { name: SeriesMarkNameEnum.point, type: MarkTypeEnum.symbol },
+	    [SeriesMarkNameEnum.line]: { name: SeriesMarkNameEnum.line, type: MarkTypeEnum.line }
+	};
 	class LineLikeSeriesMixin {
 	    initLineMark(progressive, isSeriesMark) {
 	        this._lineMark = this._createMark(lineLikeSeriesMark.line, {
@@ -56182,10 +56092,6 @@
 	        }
 	    }
 	}
-	const lineLikeSeriesMark = {
-	    [SeriesMarkNameEnum.point]: { name: SeriesMarkNameEnum.point, type: MarkTypeEnum.symbol },
-	    [SeriesMarkNameEnum.line]: { name: SeriesMarkNameEnum.line, type: MarkTypeEnum.line }
-	};
 
 	const lineSeriesMark = Object.assign(Object.assign({}, baseSeriesMark), lineLikeSeriesMark);
 
@@ -71990,702 +71896,6 @@
 	    return data;
 	};
 
-	const arcLabel = (data, op) => {
-	    const latestData = data[0].latestData;
-	    const layout = new ArcLabelLayout(op.series, latestData);
-	    return layout.updateLabels();
-	};
-	class ArcInfo {
-	    constructor(refDatum, center, outerCenter, quadrant, radian, middleAngle, k) {
-	        this.refDatum = refDatum;
-	        this.center = center;
-	        this.outerCenter = outerCenter;
-	        this.quadrant = quadrant;
-	        this.radian = radian;
-	        this.middleAngle = middleAngle;
-	        this.k = k;
-	        this.labelVisible = true;
-	        this.labelLimit = 0;
-	    }
-	    getLabelBounds() {
-	        if (!this.labelPosition || !this.labelSize) {
-	            return { x1: 0, x2: 0, y1: 0, y2: 0 };
-	        }
-	        return {
-	            x1: this.labelPosition.x - this.labelSize.width / 2,
-	            y1: this.labelPosition.y - this.labelSize.height / 2,
-	            x2: this.labelPosition.x + this.labelSize.width / 2,
-	            y2: this.labelPosition.y + this.labelSize.height / 2
-	        };
-	    }
-	}
-	class ArcLabelLayout {
-	    constructor(series, data) {
-	        this._ellipsisWidth = 0;
-	        this._arcLeft = new Map();
-	        this._arcRight = new Map();
-	        this._series = series;
-	        this._data = data;
-	        this._textMeasure = initTextMeasure(this._getMeasureSpec());
-	    }
-	    updateLabels() {
-	        const labelConfig = this._series.getLabelConfig();
-	        if (!(labelConfig === null || labelConfig === void 0 ? void 0 : labelConfig.visible)) {
-	            return null;
-	        }
-	        this._setArcs();
-	        this._layoutLabels();
-	        return this._setLabelData();
-	    }
-	    _setArcs() {
-	        var _a, _b, _c;
-	        const valueField = this._series.getRadiusField()[0];
-	        const radiusRatio = this._series.getRadius();
-	        const labelConfig = this._series.getLabelConfig();
-	        const line1MinLength = labelConfig.line.line1MinLength;
-	        if (labelConfig === null || labelConfig === void 0 ? void 0 : labelConfig.visible) {
-	            this._clearArcs();
-	            const radius = this._series.computeRadius(radiusRatio);
-	            const center = this._series.center;
-	            const data = (_c = (_b = (_a = this._series).getViewData) === null || _b === void 0 ? void 0 : _b.call(_a)) === null || _c === void 0 ? void 0 : _c.latestData;
-	            let values;
-	            if (data.length <= 1) {
-	                values = data.slice();
-	            }
-	            else {
-	                switch (labelConfig === null || labelConfig === void 0 ? void 0 : labelConfig.showRule) {
-	                    case 'headAndTail':
-	                        values = [data[0], data[data.length - 1]];
-	                        break;
-	                    case 'max':
-	                        values = [
-	                            data.reduce((max, value) => {
-	                                return max[valueField] > value[valueField] ? max : value;
-	                            }, data[0])
-	                        ];
-	                        break;
-	                    case 'min':
-	                        values = [
-	                            data.reduce((min, value) => {
-	                                return min[valueField] < value[valueField] ? min : value;
-	                            }, data[0])
-	                        ];
-	                        break;
-	                    case 'minAndMax':
-	                        values = [
-	                            data.reduce((max, value) => {
-	                                return max[valueField] > value[valueField] ? max : value;
-	                            }, data[0]),
-	                            data.reduce((min, value) => {
-	                                return min[valueField] < value[valueField] ? min : value;
-	                            }, data[0])
-	                        ];
-	                        break;
-	                    case 'all':
-	                    default:
-	                        values = data.slice();
-	                }
-	            }
-	            this._ellipsisWidth = this._measureTextSize('...').width;
-	            for (const item of values) {
-	                const arcMiddle = circlePoint$1(center.x, center.y, radius * item[ARC_K], item[ARC_MIDDLE_ANGLE]);
-	                const outerArcMiddle = circlePoint$1(center.x, center.y, radius + line1MinLength, item[ARC_MIDDLE_ANGLE]);
-	                const arc = new ArcInfo(item, arcMiddle, outerArcMiddle, item[ARC_QUADRANT], item[ARC_RADIAN], item[ARC_MIDDLE_ANGLE], item[ARC_K]);
-	                const text = this._getFormatLabelText(item);
-	                arc.labelSize = this._measureTextSize(text);
-	                if (isQuadrantRight$1(arc.quadrant)) {
-	                    this._arcRight.set(arc.refDatum, arc);
-	                }
-	                else if (isQuadrantLeft$1(arc.quadrant)) {
-	                    this._arcLeft.set(arc.refDatum, arc);
-	                }
-	            }
-	        }
-	    }
-	    _getArc(datum) {
-	        return this._arcLeft.get(datum) || this._arcRight.get(datum);
-	    }
-	    _clearArcs() {
-	        this._arcLeft.clear();
-	        this._arcRight.clear();
-	    }
-	    _setLabelData() {
-	        const labelConfig = this._series.getLabelConfig();
-	        const center = this._series.center;
-	        return this._data.map((v) => {
-	            const arc = this._getArc(v);
-	            const value = Object.assign({}, v);
-	            if (!arc) {
-	                value[DEFAULT_LABEL_VISIBLE] = false;
-	                return value;
-	            }
-	            const { labelPosition, labelLimit, labelSize, pointB, pointC } = arc;
-	            if ((labelConfig === null || labelConfig === void 0 ? void 0 : labelConfig.position) !== 'inside') {
-	                const hoverLineA = circlePoint$1(center.x, center.y, this._series.computeDatumRadius(value, STATE_VALUE_ENUM.STATE_HOVER), arc.middleAngle);
-	                const selectedLineA = circlePoint$1(center.x, center.y, this._series.computeDatumRadius(value, STATE_VALUE_ENUM.STATE_SELECTED), arc.middleAngle);
-	                const pointA = circlePoint$1(center.x, center.y, this._series.computeDatumRadius(value, STATE_VALUE_ENUM.STATE_NORMAL), arc.middleAngle);
-	                value[ARC_LABEL_POINT_AX] = pointA.x;
-	                value[ARC_LABEL_POINT_AY] = pointA.y;
-	                value[ARC_LABEL_HOVER_AX] = hoverLineA.x;
-	                value[ARC_LABEL_HOVER_AY] = hoverLineA.y;
-	                value[ARC_LABEL_SELECTED_AX] = selectedLineA.x;
-	                value[ARC_LABEL_SELECTED_AY] = selectedLineA.y;
-	                value[ARC_LABEL_POINT_BX] = pointB.x;
-	                value[ARC_LABEL_POINT_BY] = pointB.y;
-	                value[ARC_LABEL_POINT_CX] = pointC.x;
-	                value[ARC_LABEL_POINT_CY] = pointC.y;
-	                value[DEFAULT_LABEL_Y] = labelPosition.y - labelSize.height / 2;
-	            }
-	            else {
-	                value[DEFAULT_LABEL_Y] = labelPosition.y;
-	            }
-	            value[DEFAULT_LABEL_ALIGN] = this._computeAlign(arc);
-	            value[DEFAULT_LABEL_LIMIT] = Math.max(labelLimit, 0);
-	            value[DEFAULT_LABEL_VISIBLE] = arc.labelVisible && !isNil(arc.labelText);
-	            value[DEFAULT_LABEL_X] = labelPosition.x;
-	            value[DEFAULT_LABEL_TEXT] = arc.labelText;
-	            return value;
-	        });
-	    }
-	    _layoutLabels() {
-	        const labelConfig = this._series.getLabelConfig();
-	        const leftArcs = Array.from(this._arcLeft.values());
-	        const rightArcs = Array.from(this._arcRight.values());
-	        if ((labelConfig === null || labelConfig === void 0 ? void 0 : labelConfig.position) === 'inside') {
-	            this._layoutInsideLabels(rightArcs);
-	            this._layoutInsideLabels(leftArcs);
-	        }
-	        else {
-	            this._layoutOutsideLabels(rightArcs);
-	            this._layoutOutsideLabels(leftArcs);
-	        }
-	    }
-	    _layoutInsideLabels(arcs) {
-	        const center = this._series.center;
-	        const innerRadiusRatio = this._series.getInnerRadius();
-	        const outerRadiusRatio = this._series.getRadius();
-	        const labelConfig = this._series.getLabelConfig();
-	        const spaceWidth = labelConfig.spaceWidth;
-	        arcs.forEach((arc) => {
-	            const { labelSize, radian } = arc;
-	            const innerRadius = this._series.computeRadius(innerRadiusRatio, 1);
-	            const outerRadius = this._series.computeRadius(outerRadiusRatio);
-	            const minRadian = connectLineRadian$1(outerRadius, labelSize.height);
-	            let limit;
-	            if (radian < minRadian) {
-	                limit = 0;
-	            }
-	            else {
-	                let minRadius;
-	                if (radian >= Math.PI) {
-	                    minRadius = innerRadius;
-	                }
-	                else {
-	                    minRadius = Math.max(innerRadius, labelSize.height / 2 / Math.tan(radian / 2));
-	                }
-	                limit = outerRadius - minRadius - spaceWidth;
-	            }
-	            if ((labelConfig === null || labelConfig === void 0 ? void 0 : labelConfig.rotate) !== true) {
-	                limit = outerRadius - spaceWidth;
-	            }
-	            const text = this._getFormatLabelText(arc.refDatum, limit);
-	            arc.labelText = text;
-	            const labelWidth = Math.min(limit, this._measureTextSize(text).width);
-	            const align = this._computeAlign(arc);
-	            const alignOffset = align === 'left' ? labelWidth : align === 'right' ? 0 : labelWidth / 2;
-	            const labelRadius = outerRadius - spaceWidth - alignOffset;
-	            arc.labelPosition = circlePoint$1(center.x, center.y, labelRadius, arc.middleAngle);
-	            arc.labelLimit = labelWidth;
-	            if (!isGreater(labelWidth, 0)) {
-	                arc.labelVisible = false;
-	            }
-	        });
-	    }
-	    _layoutOutsideLabels(arcs) {
-	        var _a;
-	        const { height } = this._getPlotLayout();
-	        const labelConfig = this._series.getLabelConfig();
-	        const line2MinLength = labelConfig.line.line2MinLength;
-	        const labelLayout = labelConfig.layout;
-	        const spaceWidth = labelConfig.spaceWidth;
-	        arcs.forEach(arc => {
-	            const direction = isQuadrantLeft$1(arc.quadrant) ? -1 : 1;
-	            arc.labelPosition = {
-	                x: arc.outerCenter.x + direction * (arc.labelSize.width / 2 + line2MinLength + spaceWidth),
-	                y: arc.outerCenter.y
-	            };
-	        });
-	        arcs.sort((a, b) => {
-	            return a.labelPosition.y - b.labelPosition.y;
-	        });
-	        if (labelConfig.coverEnable !== false || labelLayout.strategy === 'none') {
-	            for (const arc of arcs) {
-	                const { labelPosition, labelSize } = arc;
-	                arc.labelLimit = labelSize.width;
-	                arc.pointB = isQuadrantLeft$1(arc.quadrant)
-	                    ? {
-	                        x: labelPosition.x + labelSize.width / 2 + line2MinLength + spaceWidth,
-	                        y: labelPosition.y
-	                    }
-	                    : {
-	                        x: labelPosition.x - labelSize.width / 2 - line2MinLength - spaceWidth,
-	                        y: labelPosition.y
-	                    };
-	                this._computeX(arc);
-	            }
-	            if (labelConfig.coverEnable === false && labelLayout.strategy === 'none') {
-	                this._coverLabels(arcs);
-	            }
-	        }
-	        else {
-	            const maxLabels = height / (((_a = labelConfig.style) === null || _a === void 0 ? void 0 : _a.fontSize) || 16);
-	            this._adjustY(arcs, maxLabels);
-	            const { minY, maxY } = arcs.reduce((yInfo, arc) => {
-	                const { y1, y2 } = arc.getLabelBounds();
-	                yInfo.minY = Math.max(0, Math.min(y1, yInfo.minY));
-	                yInfo.maxY = Math.min(height, Math.max(y2, yInfo.maxY));
-	                return yInfo;
-	            }, { minY: Infinity, maxY: -Infinity });
-	            const halfY = Math.max(Math.abs(height / 2 - minY), Math.abs(maxY - height / 2));
-	            const r = this._computeLayoutRadius(halfY);
-	            for (const arc of arcs) {
-	                this._computePointB(arc, r);
-	                this._computeX(arc);
-	            }
-	        }
-	        const { width } = this._getPlotLayout();
-	        arcs.forEach(arc => {
-	            if (arc.labelVisible &&
-	                (isLess(arc.pointB.x, line2MinLength + spaceWidth) ||
-	                    isGreater(arc.pointB.x, width - line2MinLength - spaceWidth))) {
-	                arc.labelVisible = false;
-	            }
-	        });
-	    }
-	    _coverLabels(arcs) {
-	        if (arcs.length <= 1) {
-	            return;
-	        }
-	        let lastBounds = arcs[0].getLabelBounds();
-	        for (let i = 1; i < arcs.length; i++) {
-	            const bounds = arcs[i].getLabelBounds();
-	            if (!checkBoundsOverlap$1(lastBounds, bounds)) {
-	                lastBounds = bounds;
-	            }
-	            else {
-	                arcs[i].labelVisible = false;
-	            }
-	        }
-	    }
-	    _computeLayoutRadius(halfYLength) {
-	        const labelConfig = this._series.getLabelConfig();
-	        const layoutArcGap = labelConfig.layoutArcGap;
-	        const line1MinLength = labelConfig.line.line1MinLength;
-	        const radiusRatio = this._series.getRadius();
-	        const radius = this._series.computeRadius(radiusRatio);
-	        const outerR = Math.max(radius + line1MinLength, this._series.computeDatumRadius(null));
-	        const a = outerR - layoutArcGap;
-	        return Math.max((a ** 2 + halfYLength ** 2) / (2 * a), outerR);
-	    }
-	    _computePointB(arc, r) {
-	        const radiusRatio = this._series.getRadius();
-	        const labelConfig = this._series.getLabelConfig();
-	        const line1MinLength = labelConfig.line.line1MinLength;
-	        const labelLayout = labelConfig.layout;
-	        if (labelLayout.strategy === 'none') {
-	            arc.pointB = {
-	                x: arc.outerCenter.x,
-	                y: arc.outerCenter.y
-	            };
-	        }
-	        else {
-	            const center = this._series.center;
-	            const radius = this._series.computeRadius(radiusRatio);
-	            const { labelPosition, quadrant } = arc;
-	            const outerR = Math.max(radius + line1MinLength, this._series.computeDatumRadius(null));
-	            const rd = r - outerR;
-	            const x = Math.sqrt(r ** 2 - Math.abs(center.y - labelPosition.y) ** 2) - rd;
-	            if (isValidNumber(x)) {
-	                arc.pointB = {
-	                    x: center.x + x * (isQuadrantLeft$1(quadrant) ? -1 : 1),
-	                    y: labelPosition.y
-	                };
-	            }
-	            else {
-	                arc.pointB = { x: NaN, y: NaN };
-	            }
-	        }
-	    }
-	    _computeX(arc) {
-	        var _a;
-	        const center = this._series.center;
-	        const plotLayout = this._getPlotLayout();
-	        const radiusRatio = this._series.getRadius();
-	        const labelConfig = this._series.getLabelConfig();
-	        const line1MinLength = labelConfig.line.line1MinLength;
-	        const line2MinLength = labelConfig.line.line2MinLength;
-	        const labelLayoutAlign = (_a = labelConfig.layout) === null || _a === void 0 ? void 0 : _a.align;
-	        const spaceWidth = labelConfig.spaceWidth;
-	        const align = this._computeAlign(arc);
-	        const { labelPosition, quadrant, pointB } = arc;
-	        if (!isValidNumber(pointB.x * pointB.y)) {
-	            arc.pointC = { x: NaN, y: NaN };
-	            labelPosition.x = NaN;
-	            arc.labelLimit = 0;
-	        }
-	        const radius = this._series.computeRadius(radiusRatio);
-	        const flag = isQuadrantLeft$1(quadrant) ? -1 : 1;
-	        let cx = 0;
-	        const restWidth = flag > 0 ? plotLayout.width - pointB.x : pointB.x;
-	        let limit = restWidth - line2MinLength - spaceWidth;
-	        if (labelLayoutAlign === 'labelLine') {
-	            cx = (radius + line1MinLength + line2MinLength) * flag + center.x;
-	            limit = (flag > 0 ? plotLayout.width - cx : cx) - spaceWidth;
-	        }
-	        const text = this._getFormatLabelText(arc.refDatum, limit);
-	        arc.labelText = text;
-	        let labelWidth = Math.min(limit, this._measureTextSize(text).width);
-	        switch (labelLayoutAlign) {
-	            case 'labelLine':
-	                break;
-	            case 'edge':
-	                cx = flag > 0 ? plotLayout.width - labelWidth - spaceWidth : labelWidth + spaceWidth;
-	                break;
-	            case 'arc':
-	            default:
-	                cx = pointB.x + flag * line2MinLength;
-	                break;
-	        }
-	        labelWidth = Math.max(this._ellipsisWidth, labelWidth);
-	        arc.pointC = { x: cx, y: labelPosition.y };
-	        if (labelLayoutAlign === 'edge') {
-	            const alignOffset = this._computeAlignOffset(align, labelWidth, -flag);
-	            labelPosition.x = flag > 0 ? plotLayout.width + alignOffset : alignOffset;
-	        }
-	        else {
-	            const alignOffset = this._computeAlignOffset(align, labelWidth, flag);
-	            labelPosition.x = cx + alignOffset + flag * spaceWidth;
-	        }
-	        arc.labelLimit = labelWidth;
-	    }
-	    _computeAlignOffset(align, labelWidth, alignFlag) {
-	        switch (align) {
-	            case 'left':
-	                return alignFlag < 0 ? -labelWidth : 0;
-	            case 'right':
-	                return alignFlag < 0 ? 0 : labelWidth;
-	            case 'center':
-	            default:
-	                return (labelWidth / 2) * alignFlag;
-	        }
-	    }
-	    _adjustY(arcs, maxLabels) {
-	        const plotRect = this._getPlotLayout();
-	        const labelLayout = this._series.getLabelConfig().layout;
-	        if (labelLayout.strategy === 'vertical') {
-	            let lastY = 0;
-	            let delta;
-	            const len = arcs.length;
-	            if (len <= 0) {
-	                return;
-	            }
-	            for (let i = 0; i < len; i++) {
-	                const { y1 } = arcs[i].getLabelBounds();
-	                delta = y1 - lastY;
-	                if (isLess(delta, 0)) {
-	                    const index = this._shiftY(arcs, i, len - 1, -delta);
-	                    this._shiftY(arcs, index, 0, delta / 2);
-	                }
-	                const { y2 } = arcs[i].getLabelBounds();
-	                lastY = y2;
-	            }
-	            const { y1: firstY1 } = arcs[0].getLabelBounds();
-	            delta = firstY1 - 0;
-	            if (isLess(delta, 0)) {
-	                this._shiftY(arcs, 0, len - 1, -delta);
-	            }
-	            for (let i = arcs.length - 1; i >= 0; i--) {
-	                if (arcs[i].getLabelBounds().y2 > plotRect.height) {
-	                    arcs[i].labelVisible = false;
-	                }
-	                else {
-	                    break;
-	                }
-	            }
-	        }
-	        else if (labelLayout.strategy !== 'none') {
-	            const priorityArcs = arcs.map((arc, i) => {
-	                return {
-	                    arc,
-	                    originIndex: i,
-	                    priorityIndex: 0
-	                };
-	            });
-	            priorityArcs.sort((a, b) => {
-	                return b.arc.radian - a.arc.radian;
-	            });
-	            priorityArcs.forEach((priorityArc, i) => {
-	                priorityArc.priorityIndex = i;
-	                priorityArc.arc.labelVisible = false;
-	            });
-	            let topLabelIndex = Infinity;
-	            let bottomLabelIndex = -Infinity;
-	            for (let i = 0; i < maxLabels && i < arcs.length; i++) {
-	                this._storeY(arcs);
-	                const arc = priorityArcs[i].arc;
-	                this._computeYRange(arc);
-	                arc.labelVisible = true;
-	                const curY = arc.labelPosition.y;
-	                const { lastIndex, nextIndex } = this._findNeighborIndex(arcs, priorityArcs[i]);
-	                const lastArc = arcs[lastIndex];
-	                const nextArc = arcs[nextIndex];
-	                if (lastIndex === -1 && nextIndex !== -1) {
-	                    const nextY = nextArc.labelPosition.y;
-	                    if (curY > nextY) {
-	                        arc.labelPosition.y = nextY - nextArc.labelSize.height / 2 - arc.labelSize.height / 2;
-	                    }
-	                    else {
-	                        this._twoWayShift(arcs, arc, nextArc, nextIndex);
-	                    }
-	                }
-	                else if (lastIndex !== -1 && nextIndex === -1) {
-	                    const lastY = lastArc.labelPosition.y;
-	                    if (curY < lastY) {
-	                        arc.labelPosition.y = lastY + lastArc.labelSize.height / 2 + arc.labelSize.height / 2;
-	                    }
-	                    else {
-	                        this._twoWayShift(arcs, lastArc, arc, priorityArcs[i].originIndex);
-	                    }
-	                }
-	                else if (lastIndex !== -1 && nextIndex !== -1) {
-	                    const lastY = lastArc.labelPosition.y;
-	                    const nextY = nextArc.labelPosition.y;
-	                    if (curY > nextY) {
-	                        arc.labelPosition.y = nextY - nextArc.labelSize.height / 2 - arc.labelSize.height / 2;
-	                        this._twoWayShift(arcs, lastArc, arc, priorityArcs[i].originIndex);
-	                    }
-	                    else if (curY < lastY) {
-	                        arc.labelPosition.y = lastY + lastArc.labelSize.height / 2 + arc.labelSize.height / 2;
-	                        this._twoWayShift(arcs, arc, nextArc, nextIndex);
-	                    }
-	                    else {
-	                        this._twoWayShift(arcs, lastArc, arc, priorityArcs[i].originIndex);
-	                        this._twoWayShift(arcs, arc, nextArc, nextIndex);
-	                    }
-	                }
-	                const nextTopIndex = Math.min(topLabelIndex, priorityArcs[i].originIndex);
-	                const nextBottomIndex = Math.max(bottomLabelIndex, priorityArcs[i].originIndex);
-	                let delta;
-	                delta = arcs[nextBottomIndex].getLabelBounds().y2 - plotRect.height;
-	                if (isGreater(delta, 0)) {
-	                    this._shiftY(arcs, nextBottomIndex, 0, -delta);
-	                }
-	                delta = arcs[nextTopIndex].getLabelBounds().y1 - 0;
-	                if (isLess(delta, 0)) {
-	                    this._shiftY(arcs, nextTopIndex, arcs.length - 1, -delta);
-	                }
-	                delta = arcs[nextBottomIndex].getLabelBounds().y2 - plotRect.height;
-	                if (isGreater(delta, 0)) {
-	                    arc.labelVisible = false;
-	                    this._restoreY(arcs);
-	                    break;
-	                }
-	                else if (labelLayout.tangentConstraint && !this._checkYRange(arcs)) {
-	                    arc.labelVisible = false;
-	                    this._restoreY(arcs);
-	                }
-	                else {
-	                    topLabelIndex = nextTopIndex;
-	                    bottomLabelIndex = nextBottomIndex;
-	                }
-	            }
-	        }
-	    }
-	    _checkYRange(arcs) {
-	        for (const arc of arcs) {
-	            const { labelYRange, labelPosition } = arc;
-	            if (arc.labelVisible &&
-	                labelYRange &&
-	                (isLess(labelPosition.y, labelYRange[0]) || isGreater(labelPosition.y, labelYRange[1]))) {
-	                return false;
-	            }
-	        }
-	        return true;
-	    }
-	    _computeYRange(arc) {
-	        const plotRect = this._getPlotLayout();
-	        const radiusRatio = this._series.getRadius();
-	        const line1MinLength = this._series.getLabelConfig().line.line1MinLength;
-	        const { width, height } = plotRect;
-	        const radius = this._series.computeRadius(radiusRatio);
-	        const r = this._computeLayoutRadius(height / 2);
-	        const cx = Math.abs(arc.center.x - width / 2);
-	        const cy = arc.center.y - height / 2;
-	        let a;
-	        let b;
-	        let c;
-	        if (isClose(width / 2, cx)) {
-	            a = 0;
-	            b = 1;
-	            c = -cy;
-	        }
-	        else if (isClose(height / 2, cy)) {
-	            a = 1;
-	            b = 0;
-	            c = -cx;
-	        }
-	        else {
-	            const k = -1 / (cy / cx);
-	            a = k;
-	            b = -1;
-	            c = cy - k * cx;
-	        }
-	        const points = lineCirclePoints$1(a, b, c, line1MinLength + radius - r, 0, r);
-	        if (points.length < 2) {
-	            return;
-	        }
-	        let min;
-	        let max;
-	        if (points[0].x > points[1].x) {
-	            points.reverse();
-	        }
-	        if (points[0].x < 0) {
-	            if (isClose(points[0].y, points[1].y)) {
-	                if (Math.abs(arc.middleAngle) < Math.PI / 2) {
-	                    min = 0;
-	                    max = points[1].y + height / 2;
-	                }
-	                else {
-	                    min = points[1].y + height / 2;
-	                    max = height;
-	                }
-	            }
-	            else if (points[0].y < points[1].y) {
-	                min = 0;
-	                max = points[1].y + height / 2;
-	            }
-	            else {
-	                min = points[1].y + height / 2;
-	                max = plotRect.height;
-	            }
-	        }
-	        else {
-	            min = Math.min(points[0].y, points[1].y) + height / 2;
-	            max = Math.max(points[0].y, points[1].y) + height / 2;
-	        }
-	        arc.labelYRange = [min, max];
-	    }
-	    _storeY(arcs) {
-	        for (const arc of arcs) {
-	            if (arc.labelVisible) {
-	                arc.lastLabelY = arc.labelPosition.y;
-	            }
-	        }
-	    }
-	    _restoreY(arcs) {
-	        for (const arc of arcs) {
-	            if (arc.labelVisible) {
-	                arc.labelPosition.y = arc.lastLabelY;
-	            }
-	        }
-	    }
-	    _findNeighborIndex(arcs, priorityArc) {
-	        const index = priorityArc.originIndex;
-	        let lastIndex = -1;
-	        let nextIndex = -1;
-	        for (let i = index - 1; i >= 0; i--) {
-	            if (arcs[i].labelVisible) {
-	                lastIndex = i;
-	                break;
-	            }
-	        }
-	        for (let i = index + 1; i < arcs.length; i++) {
-	            if (arcs[i].labelVisible) {
-	                nextIndex = i;
-	                break;
-	            }
-	        }
-	        return {
-	            lastIndex,
-	            nextIndex
-	        };
-	    }
-	    _twoWayShift(arcs, lastArc, nextArc, nextIndex) {
-	        const delta = nextArc.getLabelBounds().y1 - lastArc.getLabelBounds().y2;
-	        if (isLess(delta, 0)) {
-	            const i = this._shiftY(arcs, nextIndex, arcs.length - 1, -delta);
-	            this._shiftY(arcs, i, 0, delta / 2);
-	        }
-	    }
-	    _shiftY(arcs, start, end, delta) {
-	        const direction = start < end ? 1 : -1;
-	        let index = start;
-	        while (index !== -1) {
-	            arcs[index].labelPosition.y += delta;
-	            const nextIndex = this._findNextVisibleIndex(arcs, index, end, direction);
-	            if (nextIndex >= 0 && nextIndex < arcs.length) {
-	                const { y1: curY1, y2: curY2 } = arcs[index].getLabelBounds();
-	                const { y1: nextY1, y2: nextY2 } = arcs[nextIndex].getLabelBounds();
-	                if ((direction > 0 && curY2 < nextY1) || (direction < 0 && curY1 > nextY2)) {
-	                    return index;
-	                }
-	            }
-	            index = nextIndex;
-	        }
-	        return end;
-	    }
-	    _findNextVisibleIndex(arcs, start, end, direction) {
-	        const diff = (end - start) * direction;
-	        for (let i = 1; i <= diff; i++) {
-	            const index = start + i * direction;
-	            if (arcs[index].labelVisible) {
-	                return index;
-	            }
-	        }
-	        return -1;
-	    }
-	    _computeAlign(arc) {
-	        var _a, _b, _c, _d, _e, _f;
-	        const labelConfig = this._series.getLabelConfig();
-	        const textAlign = (_b = (_a = labelConfig.style) === null || _a === void 0 ? void 0 : _a.textAlign) !== null && _b !== void 0 ? _b : (_c = labelConfig.style) === null || _c === void 0 ? void 0 : _c.align;
-	        const layoutAlign = (_e = (_d = labelConfig.layout) === null || _d === void 0 ? void 0 : _d.textAlign) !== null && _e !== void 0 ? _e : (_f = labelConfig.layout) === null || _f === void 0 ? void 0 : _f.align;
-	        if (labelConfig.position !== 'inside') {
-	            if (isNil(textAlign) || textAlign === 'auto') {
-	                if (layoutAlign === 'edge') {
-	                    return isQuadrantLeft$1(arc.quadrant) ? 'left' : 'right';
-	                }
-	                return isQuadrantLeft$1(arc.quadrant) ? 'right' : 'left';
-	            }
-	            return textAlign;
-	        }
-	        return isNil(textAlign) || textAlign === 'auto' ? 'center' : textAlign;
-	    }
-	    _getFormatLabelText(value, limit) {
-	        var _a;
-	        const textSpec = (_a = this._series.getLabelConfig().style) === null || _a === void 0 ? void 0 : _a.text;
-	        const seriesField = this._series.getSeriesField();
-	        const angleField = this._series.getAngleField()[0];
-	        const isInvalidLabel = isNil(seriesField) || isNil(value[seriesField]) || isNil(value[angleField]);
-	        if (isFunction(textSpec)) {
-	            return isInvalidLabel ? null : textSpec.call(null, value, {});
-	        }
-	        return isInvalidLabel ? null : value[seriesField];
-	    }
-	    _getMeasureSpec() {
-	        return Object.assign(Object.assign({}, this._series.getLabelConfig().style), { textAlign: 'center' });
-	    }
-	    _measureTextSize(text) {
-	        const size = this._textMeasure.quickMeasure(text);
-	        return {
-	            width: Math.ceil(size.width) + 1,
-	            height: size.height
-	        };
-	    }
-	    _getPlotLayout() {
-	        return this._series.getRegion().getLayoutRect();
-	    }
-	}
-
 	function centerOffsetConfig(mark, originalConfig) {
 	    var _a, _b, _c, _d;
 	    const offset = (_b = (_a = originalConfig.options) === null || _a === void 0 ? void 0 : _a.distance) !== null && _b !== void 0 ? _b : 10;
@@ -72811,7 +72021,6 @@
 	            return;
 	        }
 	        registerDataSetInstanceTransform(this._dataSet, 'pie', pie);
-	        registerDataSetInstanceTransform(this._dataSet, 'arcLabel', arcLabel);
 	        viewData.transform({
 	            type: 'pie',
 	            options: {
@@ -72832,10 +72041,6 @@
 	            type: 'dataview'
 	        });
 	        viewDataLabel.name = `${PREFIX}_series_${this.id}_viewDataLabel`;
-	        viewDataLabel.transform({
-	            type: 'arcLabel',
-	            options: { series: this }
-	        }, false);
 	        this._viewDataLabel = new SeriesData(this._option, viewDataLabel);
 	    }
 	    initMark() {
@@ -86639,10 +85844,14 @@
 	            type: 'discreteLegendDataMake',
 	            options: {
 	                series: () => {
-	                    return this._regions.reduce((pre, r) => {
-	                        pre.push(...r.getSeries());
-	                        return pre;
-	                    }, []);
+	                    const result = [];
+	                    eachSeries(this._regions, s => {
+	                        result.push(s);
+	                    }, {
+	                        specIndex: this._spec.seriesIndex,
+	                        userId: this._spec.seriesId
+	                    });
+	                    return result;
 	                },
 	                seriesField: (s) => this._getSeriesLegendField(s)
 	            }